# vim: mode=python fenc=utf-8 fileformat=unix:

# Author: 2004-2006 Gulácsi Tamás

#

# Ported from Josh Carter's Perl IPTCInfo.pm by Tam?s Gul?csi

# it under the same terms as Python itself.

#

# VERSION = '1.9';

IPTCInfo - Python module for extracting and modifying IPTC image meta-data

Ported from Josh Carter's Perl IPTCInfo-1.9.pm by Tamás Gulácsi

"""

__version__ = '1.9.2-rc7'

SURELY_WRITE_CHARSET_INFO = False

}

c_datasets_r = dict([(v, k) for k, v in c_datasets.iteritems()])

class IPTCData(dict):

  """Dict with int/string keys from c_listdatanames"""

    fh2.close()

    return True

    """Called when object is destroyed. No action necessary in this case."""

    pass

  def getData(self):

    return self._data

    raise Exception('You cannot overwrite the data, only its elements!')

  data = property(getData, setData)

    filename, and the XML will be dumped into there."""

    def P(s):

      return '  '*off + s + '\n'

    off = 0

    if len(basetag) == 0: basetag = 'photo'

    off += 1

    # dump extra info first, if any

    # dump our stuff

    for k, v in self._data.iteritems():

      if not isinstance(v, list):

        key = re.sub('/', '-', re.sub(' +', ' ', self._data.keyAsStr(k)))

    # print keywords

    kw = self.keywords()

    if kw and len(kw) > 0:

      off += 1

      off -= 1

    # print supplemental categories

    sc = self.supplementalCategories()

    if sc and len(sc) > 0:

      off += 1

      for k in sc:

      off -= 1

    # print contacts

    kw = self.contacts()

    if kw and len(kw) > 0:

      off += 1

      off -= 1

    # close base tag

    off -= 1

    # export to file if caller asked for it.

    if len(filename) > 0:

      xmlout.write(out)

      xmlout.close()

  def exportSQL(self, tablename, mappings, extra):

    """statement = info.exportSQL('mytable', mappings, extra-data)

    # start with extra data, if any

    columns = ', '.join(extra.keys() + mappings.keys())

    values = ', '.join(map(E, extra.values()

    # process our data

    statement = "INSERT INTO %s (%s) VALUES (%s)" \

      # and, if unsuccessful, into _data. Tags which are not in the

      # current IIM spec (version 4) are currently discarded.

      if self._data.has_key(dataset) and isinstance(self._data[dataset], list):

      elif dataset != 0:

        self._data[dataset] = value

    ## assert isinstance(fh, file)

    assert duck_typed(fh, ['seek', 'read'])

    adobeParts = ''

    # Start at beginning of file

    fh.seek(0, 0)

      return None

    # Begin building start of file

    # Get first marker in file. This will be APP0 for JFIF or APP1 for

    # EXIF.

    if ord(marker) == 0xe0 or not discardAppParts:

      # Always include APP0 marker at start if it's present.

      # Remember that the length must include itself (2 bytes)

    else:

      # Manually insert APP0 if we're trashing application parts, since

      # all JFIF format images should start with the version block.

      debug(2, 'discardAppParts=', discardAppParts)

    # Now scan through all markers in file until we hit image data or

    # IPTC stuff.

    while 1:

      marker = self.jpegNextMarker(fh)

      if marker is None or ord(marker) == 0:

      # Check for end of image

      elif ord(marker) == 0xd9:

        self.log("JpegCollectFileParts: saw end of image marker")

        break

      # Check for start of compressed data

      elif ord(marker) == 0xda:

        self.log("JpegCollectFileParts: saw start of compressed data")

        break

      partdata = ''

      partdata = self.jpegSkipVariable(fh, partdata)

        break

      else:

        # Append all other parts to start section

    # Append rest of file to end

    while 1:

      if buff is None or len(buff) == 0: break

  def collectAdobeParts(self, data):

    """Part APP13 contains yet another markup format, one defined by

    assert isinstance(data, basestring)

    length = len(data)

    offset = 0

    # Skip preamble

    offset = len('Photoshop 3.0 ')

    # Process everything

      # skip IIM data (0x0404), but write everything else out

      if not (id1 == 4 and id2 == 4):

  def _enc(self, text):

    """Recodes the given text from the old character set to utf-8"""

  def packedIIMData(self):

    """Assembles and returns our _data and _listdata into IIM format for

    embedding into an image."""

    (tag, record) = (0x1c, 0x02)

    # Print record version

    # tag - record - dataset - len (short) - 4 (short)

    debug(3, self.hexDump(out))

    # Iterate over data sets

      print value

      if not isinstance(value, list):

        value = str(value)

      else:

        for v in map(str, value):

          if v is None or len(v) == 0: continue

  def photoshopIIMBlock(self, otherparts, data):

    """Assembles the blob of Photoshop "resource data" that includes our

    fresh IIM data (from PackedIIMData) and the other Adobe parts we

    found in the file, if there were any."""

    assert isinstance(data, basestring)

    # Photoshop identifier

    # 0x0404 is IIM data, 00 is required empty string

    # length of data as 32-bit, network-byte order

    # Now tack data on there

    # Pad with a blank if not even size

    # Finally tack on other data

  #######################################################################

  # Helpers, docs

    length  = len(dump)

    P = lambda z: ((ord(z) >= 0x21 and ord(z) <= 0x7e) and [z] or ['.'])[0]

    ROWLEN = 18

      row = dump[j*ROWLEN:(j+1)*ROWLEN]

  def jpegDebugScan(self, filename):

    """Also very helpful when debugging."""

zipext = (sys.platform.startswith('Win') and ['zip'] or ['tar.gz'])[0]

setup(name='IPTCInfo',

      version=version,

      maintainer=u'Tamás Gulácsi',

      maintainer_email='gthomas@fw.hu',

      license = 'http://www.opensource.org/licenses/gpl-license.php',