def test_convert_to_string_ascii(self):
# Valid values: datetimes
tag = ExifTag("Exif.Image.DateTime")
self.assertEqual(tag.type, "Ascii")
self.assertEqual(tag._convert_to_string(datetime.datetime(2009, 03, 01, 12, 54, 28)), "2009:03:01 12:54:28")
self.assertEqual(tag._convert_to_string(datetime.date(2009, 03, 01)), "2009:03:01 00:00:00")
# Valid values: dates
tag = ExifTag("Exif.GPSInfo.GPSDateStamp")
self.assertEqual(tag.type, "Ascii")
self.assertEqual(tag._convert_to_string(datetime.date(2009, 03, 01)), "2009:03:01")
# Valid values: strings
tag = ExifTag("Exif.Image.Copyright")
self.assertEqual(tag.type, "Ascii")
self.assertEqual(tag._convert_to_string(u"Some text"), "Some text")
self.assertEqual(
tag._convert_to_string(u"Some text with exotic chàräctérʐ."), "Some text with exotic chàräctérʐ."
)
self.assertEqual(
tag._convert_to_string("Some text with exotic chàräctérʐ."), "Some text with exotic chàräctérʐ."
)
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
def test_convert_to_string_undefined(self):
# Valid values
tag = ExifTag("Exif.Photo.ExifVersion")
self.assertEqual(tag.type, "Undefined")
self.assertEqual(tag._convert_to_string("0100"), "48 49 48 48")
self.assertEqual(tag._convert_to_string(u"0100"), "48 49 48 48")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3)
def test_convert_to_string_srational(self):
# Valid values
tag = ExifTag('Exif.Image.BaselineExposure')
self.assertEqual(tag.type, 'SRational')
self.assertEqual(tag._convert_to_string(make_fraction(5, 3)), '5/3')
self.assertEqual(tag._convert_to_string(make_fraction(-5, 3)), '-5/3')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
def test_convert_to_string_rational(self):
# Valid values
tag = ExifTag("Exif.Image.XResolution")
self.assertEqual(tag.type, "Rational")
self.assertEqual(tag._convert_to_string(make_fraction(5, 3)), "5/3")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, "invalid")
self.failUnlessRaises(ExifValueError, tag._convert_to_string, make_fraction(-5, 3))
def test_convert_to_python_comment(self):
# Valid values
tag = ExifTag("Exif.Photo.UserComment")
self.assertEqual(tag.type, "Comment")
self.assertEqual(tag._convert_to_python("A comment"), "A comment")
for charset in ("Ascii", "Jis", "Unicode", "Undefined", "InvalidCharsetId"):
self.assertEqual(tag._convert_to_python('charset="%s" A comment' % charset), "A comment")
for charset in ("Ascii", "Jis", "Undefined", "InvalidCharsetId"):
self.failIfEqual(tag._convert_to_python('charset="%s" déjà vu' % charset), u"déjà vu")
def test_convert_to_string_srational(self):
# Valid values
tag = ExifTag("Exif.Image.BaselineExposure")
self.assertEqual(tag.type, "SRational")
self.assertEqual(tag._convert_to_string(make_fraction(5, 3)), "5/3")
self.assertEqual(tag._convert_to_string(make_fraction(-5, 3)), "-5/3")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, "invalid")
def test_convert_to_string_sbyte(self):
# Valid values
tag = ExifTag('Exif.Pentax.Temperature')
self.assertEqual(tag.type, 'SByte')
self.assertEqual(tag._convert_to_string('13'), '13')
self.assertEqual(tag._convert_to_string(u'13'), '13')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
def test_convert_to_python_comment(self):
# Valid values
tag = ExifTag('Exif.Photo.UserComment')
self.assertEqual(tag.type, 'Comment')
self.assertEqual(tag._convert_to_python('A comment'), 'A comment')
for charset in ('Ascii', 'Jis', 'Unicode', 'Undefined', 'InvalidCharsetId'):
self.assertEqual(tag._convert_to_python('charset="%s" A comment' % charset), 'A comment')
for charset in ('Ascii', 'Jis', 'Undefined', 'InvalidCharsetId'):
self.failIfEqual(tag._convert_to_python('charset="%s" déjà vu' % charset), u'déjà vu')
def test_convert_to_string_byte(self):
# Valid values
tag = ExifTag('Exif.GPSInfo.GPSVersionID')
self.assertEqual(tag.type, 'Byte')
self.assertEqual(tag._convert_to_string('Some text'), 'Some text')
self.assertEqual(tag._convert_to_string(u'Some text'), 'Some text')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
def test_convert_to_string_sbyte(self):
# Valid values
tag = ExifTag("Exif.Pentax.Temperature")
self.assertEqual(tag.type, "SByte")
self.assertEqual(tag._convert_to_string("13"), "13")
self.assertEqual(tag._convert_to_string(u"13"), "13")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
def test_convert_to_string_byte(self):
# Valid values
tag = ExifTag("Exif.GPSInfo.GPSVersionID")
self.assertEqual(tag.type, "Byte")
self.assertEqual(tag._convert_to_string("Some text"), "Some text")
self.assertEqual(tag._convert_to_string(u"Some text"), "Some text")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
def test_convert_to_string_undefined(self):
# Valid values
tag = ExifTag('Exif.Photo.ExifVersion')
self.assertEqual(tag.type, 'Undefined')
self.assertEqual(tag._convert_to_string('0100'), '48 49 48 48')
self.assertEqual(tag._convert_to_string(u'0100'), '48 49 48 48')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3)
def test_convert_to_string_sshort(self):
# Valid values
tag = ExifTag('Exif.Image.TimeZoneOffset')
self.assertEqual(tag.type, 'SShort')
self.assertEqual(tag._convert_to_string(12), '12')
self.assertEqual(tag._convert_to_string(-3), '-3')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def test_convert_to_string_short(self):
# Valid values
tag = ExifTag('Exif.Image.BitsPerSample')
self.assertEqual(tag.type, 'Short')
self.assertEqual(tag._convert_to_string(123), '123')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, -57)
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def test_convert_to_string_short(self):
# Valid values
tag = ExifTag("Exif.Image.BitsPerSample")
self.assertEqual(tag.type, "Short")
self.assertEqual(tag._convert_to_string(123), "123")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, -57)
self.failUnlessRaises(ExifValueError, tag._convert_to_string, "invalid")
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def test_convert_to_string_rational(self):
# Valid values
tag = ExifTag('Exif.Image.XResolution')
self.assertEqual(tag.type, 'Rational')
self.assertEqual(tag._convert_to_string(make_fraction(5, 3)), '5/3')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
self.failUnlessRaises(ExifValueError,
tag._convert_to_string, make_fraction(-5, 3))
def test_convert_to_string_sshort(self):
# Valid values
tag = ExifTag("Exif.Image.TimeZoneOffset")
self.assertEqual(tag.type, "SShort")
self.assertEqual(tag._convert_to_string(12), "12")
self.assertEqual(tag._convert_to_string(-3), "-3")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, "invalid")
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def test_convert_to_string_slong(self):
# Valid values
tag = ExifTag("Exif.OlympusCs.ManometerReading")
self.assertEqual(tag.type, "SLong")
self.assertEqual(tag._convert_to_string(123), "123")
self.assertEqual(tag._convert_to_string(678024), "678024")
self.assertEqual(tag._convert_to_string(-437), "-437")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, "invalid")
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def _set_exif_tag(self, key, tag_or_value):
# Set an EXIF tag. If the tag already exists, its value is overwritten.
if isinstance(tag_or_value, ExifTag):
tag = tag_or_value
else:
# As a handy shortcut, accept direct value assignment.
tag = ExifTag(key, tag_or_value)
tag._set_owner(self)
self._tags['exif'][tag.key] = tag
if tag.key not in self.exif_keys:
self._keys['exif'].append(tag.key)
def test_convert_to_string_long(self):
# Valid values
tag = ExifTag('Exif.Image.ImageWidth')
self.assertEqual(tag.type, 'Long')
self.assertEqual(tag._convert_to_string(123), '123')
self.assertEqual(tag._convert_to_string(678024), '678024')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, -57)
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def test_convert_to_string_long(self):
# Valid values
tag = ExifTag("Exif.Image.ImageWidth")
self.assertEqual(tag.type, "Long")
self.assertEqual(tag._convert_to_string(123), "123")
self.assertEqual(tag._convert_to_string(678024), "678024")
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, -57)
self.failUnlessRaises(ExifValueError, tag._convert_to_string, "invalid")
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def test_convert_to_python_rational(self):
# Valid values
tag = ExifTag('Exif.Image.XResolution')
self.assertEqual(tag.type, 'Rational')
self.assertEqual(tag._convert_to_python('5/3'), make_fraction(5, 3))
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, 'invalid')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '-5/3')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '5 / 3')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '5/-3')
def test_convert_to_string_slong(self):
# Valid values
tag = ExifTag('Exif.OlympusCs.ManometerReading')
self.assertEqual(tag.type, 'SLong')
self.assertEqual(tag._convert_to_string(123), '123')
self.assertEqual(tag._convert_to_string(678024), '678024')
self.assertEqual(tag._convert_to_string(-437), '-437')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
def test_convert_to_python_rational(self):
# Valid values
tag = ExifTag("Exif.Image.XResolution")
self.assertEqual(tag.type, "Rational")
self.assertEqual(tag._convert_to_python("5/3"), make_fraction(5, 3))
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "invalid")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "-5/3")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "5 / 3")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "5/-3")
def test_convert_to_python_long(self):
# Valid values
tag = ExifTag('Exif.Image.ImageWidth')
self.assertEqual(tag.type, 'Long')
self.assertEqual(tag._convert_to_python('8'), 8)
self.assertEqual(tag._convert_to_python('+5628'), 5628)
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, 'abc')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '5,64')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '47.0001')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '1E3')
def test_convert_to_python_short(self):
# Valid values
tag = ExifTag('Exif.Image.BitsPerSample')
self.assertEqual(tag.type, 'Short')
self.assertEqual(tag._convert_to_python('8'), 8)
self.assertEqual(tag._convert_to_python('+5628'), 5628)
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, 'abc')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '5,64')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '47.0001')
self.failUnlessRaises(ExifValueError, tag._convert_to_python, '1E3')
def test_convert_to_python_long(self):
# Valid values
tag = ExifTag("Exif.Image.ImageWidth")
self.assertEqual(tag.type, "Long")
self.assertEqual(tag._convert_to_python("8"), 8)
self.assertEqual(tag._convert_to_python("+5628"), 5628)
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "abc")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "5,64")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "47.0001")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "1E3")
def test_convert_to_python_short(self):
# Valid values
tag = ExifTag("Exif.Image.BitsPerSample")
self.assertEqual(tag.type, "Short")
self.assertEqual(tag._convert_to_python("8"), 8)
self.assertEqual(tag._convert_to_python("+5628"), 5628)
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "abc")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "5,64")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "47.0001")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "1E3")
def test_convert_to_python_sshort(self):
# Valid values
tag = ExifTag("Exif.Image.TimeZoneOffset")
self.assertEqual(tag.type, "SShort")
self.assertEqual(tag._convert_to_python("8"), 8)
self.assertEqual(tag._convert_to_python("+5"), 5)
self.assertEqual(tag._convert_to_python("-6"), -6)
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "abc")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "5,64")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "47.0001")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "1E3")
def test_convert_to_python_slong(self):
# Valid values
tag = ExifTag("Exif.OlympusCs.ManometerReading")
self.assertEqual(tag.type, "SLong")
self.assertEqual(tag._convert_to_python("23"), 23)
self.assertEqual(tag._convert_to_python("+5628"), 5628)
self.assertEqual(tag._convert_to_python("-437"), -437)
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "abc")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "5,64")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "47.0001")
self.failUnlessRaises(ExifValueError, tag._convert_to_python, "1E3")
def _set_exif_tag(self, key, tag_or_value):
"""Set an EXIF tag. If the tag already exists, its value is overwritten.
Args:
key -- the EXIF key
tag_or_value -- an ExifTag instance or the value of the data
"""
if isinstance(tag_or_value, ExifTag):
tag = tag_or_value
else:
# As a handy shortcut, accept direct value assignment.
tag = ExifTag(key, tag_or_value)
tag._set_owner(self)
self._tags['exif'][tag.key] = tag
if tag.key not in self.exif_keys:
self._keys['exif'].append(tag.key)
def _get_exif_tag(self, key):
# Return the EXIF tag for the given key.
# Throw a KeyError if the tag doesn't exist.
try:
return self._tags['exif'][key]
except KeyError:
_tag = self._image._getExifTag(key)
tag = ExifTag._from_existing_tag(_tag)
self._tags['exif'][key] = tag
return tag
def test_mutablemapping(self):
self._set_up_clean()
self.clean.read()
self.assertEqual(len(self.clean), 0)
self.assertTrue('Exif.Image.DateTimeOriginal' not in self.clean)
key = 'Exif.Image.DateTimeOriginal'
correctDate = datetime.datetime(2007, 3, 11)
incorrectDate = datetime.datetime(2009, 3, 25)
tag_date = ExifTag(key, correctDate)
false_tag_date = ExifTag(key, incorrectDate)
self.clean[key] = tag_date
self.assertEqual(len(self.clean), 1)
self.assertTrue('Exif.Image.DateTimeOriginal' in self.clean)
self.assertEqual(
self.clean.get('Exif.Image.DateTimeOriginal', false_tag_date),
tag_date)
self.assertEqual(self.clean.get('Exif.Image.DateTime', tag_date),
tag_date)
key = 'Exif.Photo.UserComment'
tag = ExifTag(key, 'UserComment')
self.clean[key] = tag
key = 'Iptc.Application2.Caption'
tag = IptcTag(key, ['Caption'])
self.clean[key] = tag
key = 'Xmp.dc.subject'
tag = XmpTag(key, ['subject', 'values'])
self.clean[key] = tag
self.assertTrue('Exif.Photo.UserComment' in self.clean)
self.assertTrue('Iptc.Application2.Caption' in self.clean)
self.assertTrue('Xmp.dc.subject' in self.clean)
self.clean.clear()
self.assertEqual(len(self.clean), 0)
self.assertTrue('Exif.Photo.UserComment' not in self.clean)
self.assertTrue('Iptc.Application2.Caption' not in self.clean)
self.assertTrue('Xmp.dc.subject' not in self.clean)
def test_set_exif_tag_overwrite(metadata_ro):
m = metadata_ro.metadata
m.read()
assert m._tags['exif'] == {}
# Overwrite an existing tag
tag = ExifTag('Exif.Image.DateTime',
datetime.datetime(2009, 3, 20, 20, 32, 0))
m._set_exif_tag(tag.key, tag)
assert m._tags['exif'] == {tag.key: tag}
assert tag.key in m._image._exifKeys()
assert (m._image._getExifTag(
tag.key)._getRawValue().decode('ascii') == tag.raw_value)
def test_set_exif_tag_overwrite(self):
self.metadata.read()
self.assertEqual(self.metadata._tags['exif'], {})
# Overwrite an existing tag
tag = ExifTag('Exif.Image.DateTime',
datetime.datetime(2009, 3, 20, 20, 32, 0))
self.metadata._set_exif_tag(tag.key, tag)
self.assertEqual(self.metadata._tags['exif'], {tag.key: tag})
self.assert_(tag.key in self.metadata._image._exifKeys())
self.assertEqual(
self.metadata._image._getExifTag(tag.key)._getRawValue(),
tag.raw_value)
def test_makernote_types(self):
# Makernote tags not attached to an image have an Undefined type by
# default. When read from an existing image though, their type should be
# correctly set (see https://bugs.launchpad.net/pyexiv2/+bug/781464).
tag1 = ExifTag('Exif.Pentax.PreviewResolution')
tag1.raw_value = '640 480'
self.assertEqual(tag1.type, 'Undefined')
self.failUnlessRaises(ValueError, getattr, tag1, 'value')
tag2 = ExifTag('Exif.Pentax.CameraInfo')
tag2.raw_value = '76830 20070527 2 1 4228109'
self.assertEqual(tag2.type, 'Undefined')
self.failUnlessRaises(ValueError, getattr, tag2, 'value')
filepath = testutils.get_absolute_file_path(
os.path.join('data', 'pentax-makernote.jpg'))
checksum = '646804b309a4a2d31feafe9bffc5d7f0'
self.assert_(testutils.CheckFileSum(filepath, checksum))
metadata = ImageMetadata(filepath)
metadata.read()
tag1 = metadata[tag1.key]
self.assertEqual(tag1.type, 'Short')
self.assertEqual(tag1.value, [640, 480])
tag2 = metadata[tag2.key]
self.assertEqual(tag2.type, 'Long')
self.assertEqual(tag2.value, [76830L, 20070527L, 2L, 1L, 4228109L])
def test_mutablemapping():
clean = ImageMetadata.from_buffer(EMPTY_JPG_DATA)
clean.read()
assert len(clean) == 0
assert 'Exif.Image.DateTimeOriginal' not in clean
key = 'Exif.Image.DateTimeOriginal'
correctDate = datetime.datetime(2007, 3, 11)
incorrectDate = datetime.datetime(2009, 3, 25)
tag_date = ExifTag(key, correctDate)
false_tag_date = ExifTag(key, incorrectDate)
clean[key] = tag_date
assert len(clean) == 1
assert 'Exif.Image.DateTimeOriginal' in clean
assert clean.get('Exif.Image.DateTimeOriginal', false_tag_date) == tag_date
assert clean.get('Exif.Image.DateTime', tag_date) == tag_date
key = 'Exif.Photo.UserComment'
tag = ExifTag(key, 'UserComment')
clean[key] = tag
key = 'Iptc.Application2.Caption'
tag = IptcTag(key, ['Caption'])
clean[key] = tag
key = 'Xmp.dc.subject'
tag = XmpTag(key, ['subject', 'values'])
clean[key] = tag
assert 'Exif.Photo.UserComment' in clean
assert 'Iptc.Application2.Caption' in clean
assert 'Xmp.dc.subject' in clean
clean.clear()
assert len(clean) == 0
assert 'Exif.Photo.UserComment' not in clean
assert 'Iptc.Application2.Caption' not in clean
assert 'Xmp.dc.subject' not in clean
def test_set_exif_tag_create(metadata_ro):
m = metadata_ro.metadata
m.read()
assert m._tags['exif'] == {}
# Create a new tag
tag = ExifTag('Exif.Thumbnail.Orientation', 1)
assert tag.key not in m.exif_keys
m._set_exif_tag(tag.key, tag)
assert tag.key in m.exif_keys
assert m._tags['exif'] == {tag.key: tag}
assert tag.key in m._image._exifKeys()
assert (m._image._getExifTag(
tag.key)._getRawValue().decode('ascii') == tag.raw_value)
def test_set_exif_tag_create(self):
self.metadata.read()
self.assertEqual(self.metadata._tags['exif'], {})
# Create a new tag
tag = ExifTag('Exif.Thumbnail.Orientation', 1)
self.assert_(tag.key not in self.metadata.exif_keys)
self.metadata._set_exif_tag(tag.key, tag)
self.assert_(tag.key in self.metadata.exif_keys)
self.assertEqual(self.metadata._tags['exif'], {tag.key: tag})
self.assert_(tag.key in self.metadata._image._exifKeys())
self.assertEqual(
self.metadata._image._getExifTag(tag.key)._getRawValue(),
tag.raw_value)
def test_set_exif_tag_overwrite_already_cached(self):
self.metadata.read()
self.assertEqual(self.metadata._tags['exif'], {})
# Overwrite an existing tag already cached
key = 'Exif.Image.Make'
tag = self.metadata._get_exif_tag(key)
self.assertEqual(self.metadata._tags['exif'][key], tag)
new_tag = ExifTag(key, 'World Company')
self.metadata._set_exif_tag(key, new_tag)
self.assertEqual(self.metadata._tags['exif'], {key: new_tag})
self.assert_(key in self.metadata._image._exifKeys())
self.assertEqual(
self.metadata._image._getExifTag(key)._getRawValue(),
new_tag.raw_value)
def test_set_exif_tag_overwrite_already_cached(metadata_ro):
m = metadata_ro.metadata
m.read()
assert m._tags['exif'] == {}
# Overwrite an existing tag already cached
key = 'Exif.Image.Make'
tag = m._get_exif_tag(key)
assert m._tags['exif'][key] == tag
new_tag = ExifTag(key, 'World Company')
m._set_exif_tag(key, new_tag)
assert m._tags['exif'] == {key: new_tag}
assert key in m._image._exifKeys()
assert (m._image._getExifTag(key)._getRawValue().decode('ascii') ==
new_tag.raw_value)
def test_convert_to_string_comment(self):
# Valid values
tag = ExifTag('Exif.Photo.UserComment')
self.assertEqual(tag.type, 'Comment')
self.assertEqual(tag._convert_to_string('A comment'), b'A comment')
charsets = ('Ascii', 'Jis', 'Unicode', 'Undefined')
for charset in charsets:
tag.raw_value = 'charset="%s" foo' % charset
self.assertEqual(tag._convert_to_string('A comment'), b'A comment')
self.assertEqual(tag._convert_to_string('déjà vu'),
b'd\xc3\xa9j\xc3\xa0 vu')
def test_convert_to_string_comment(self):
# Valid values
tag = ExifTag('Exif.Photo.UserComment')
self.assertEqual(tag.type, 'Comment')
self.assertEqual(tag._convert_to_string('A comment'), 'A comment')
self.assertEqual(tag._convert_to_string(u'A comment'), 'A comment')
charsets = ('Ascii', 'Jis', 'Unicode', 'Undefined')
for charset in charsets:
tag.raw_value = 'charset="%s" foo' % charset
self.assertEqual(tag._convert_to_string('A comment'),
'charset="%s" A comment' % charset)
self.assertEqual(tag._convert_to_string('déjà vu'), 'déjà vu')
# Invalid values
self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
def test_makernote_types():
# Makernote tags not attached to an image have an Undefined type by
# default. When read from an existing image though, their type should
# be correctly set.
# See <https://bugs.launchpad.net/pyexiv2/+bug/781464>.
tag1 = ExifTag('Exif.Pentax.PreviewResolution')
tag1.raw_value = '640 480'
assert tag1.type == 'Undefined'
tag2 = ExifTag('Exif.Pentax.CameraInfo')
tag2.raw_value = '76830 20070527 2 1 4228109'
assert tag2.type == 'Undefined'
with pytest.raises(ValueError):
tag2.value
metadata = load_image('pentax-makernote.jpg',
'646804b309a4a2d31feafe9bffc5d7f0')
tag1 = metadata[tag1.key]
assert tag1.type == 'Short'
assert tag1.value == [640, 480]
tag2 = metadata[tag2.key]
assert tag2.type == 'Long'
assert tag2.value == [76830, 20070527, 2, 1, 4228109]
def test_set_value():
tag = ExifTag('Exif.Thumbnail.Orientation', 1) # top, left
old_value = tag.value
tag.value = 2
assert tag.value != old_value
def test_set_raw_value_invalid():
tag = ExifTag('Exif.GPSInfo.GPSVersionID')
with pytest.raises(ValueError):
tag.raw_value = '2 0 0 foo'
def test_convert_to_python_ascii(self):
# Valid values: datetimes
tag = ExifTag('Exif.Image.DateTime')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(tag._convert_to_python('2009-03-01 12:46:51'),
datetime.datetime(2009, 3, 1, 12, 46, 51))
self.assertEqual(tag._convert_to_python('2009:03:01 12:46:51'),
datetime.datetime(2009, 3, 1, 12, 46, 51))
self.assertEqual(tag._convert_to_python('2009-03-01T12:46:51Z'),
datetime.datetime(2009, 3, 1, 12, 46, 51))
# Valid values: dates
tag = ExifTag('Exif.GPSInfo.GPSDateStamp')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(tag._convert_to_python('2009:08:04'),
datetime.date(2009, 8, 4))
# Valid values: strings
tag = ExifTag('Exif.Image.Copyright')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(tag._convert_to_python('Some text.'), 'Some text.')
self.assertEqual(
tag._convert_to_python('Some text with exotic chàräctérʐ.'),
'Some text with exotic chàräctérʐ.')
# Invalid values: datetimes
tag = ExifTag('Exif.Image.DateTime')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(tag._convert_to_python('2009-13-01 12:46:51'),
'2009-13-01 12:46:51')
self.assertEqual(tag._convert_to_python('2009-12-01'), '2009-12-01')
# Invalid values: dates
tag = ExifTag('Exif.GPSInfo.GPSDateStamp')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(tag._convert_to_python('2009:13:01'), '2009:13:01')
self.assertEqual(tag._convert_to_python('2009-12-01'), '2009-12-01')
def test_convert_to_python_sbyte(self):
# Valid values
tag = ExifTag('Exif.Pentax.Temperature')
self.assertEqual(tag.type, 'SByte')
self.assertEqual(tag._convert_to_python('15'), '15')
def test_convert_to_python_undefined(self):
# Valid values
tag = ExifTag('Exif.Photo.ExifVersion')
self.assertEqual(tag.type, 'Undefined')
self.assertEqual(tag._convert_to_python('48 49 48 48'), '0100')
def test_set_value(self):
tag = ExifTag('Exif.Thumbnail.Orientation', 1) # top, left
old_value = tag.value
tag.value = 2
self.failIfEqual(tag.value, old_value)
def test_set_raw_value_invalid(self):
tag = ExifTag('Exif.GPSInfo.GPSVersionID')
value = '2 0 0 foo'
self.failUnlessRaises(ValueError, setattr, tag, 'raw_value', value)
def test_convert_to_python_byte(self):
# Valid values
tag = ExifTag('Exif.GPSInfo.GPSVersionID')
self.assertEqual(tag.type, 'Byte')
self.assertEqual(tag._convert_to_python('D'), 'D')
def test_convert_to_string_ascii(self):
# Valid values: datetimes
tag = ExifTag('Exif.Image.DateTime')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(
tag._convert_to_string(datetime.datetime(2009, 3, 1, 12, 54, 28)),
'2009:03:01 12:54:28')
self.assertEqual(tag._convert_to_string(datetime.date(2009, 3, 1)),
'2009:03:01 00:00:00')
self.assertEqual(
tag._convert_to_string(datetime.datetime(1899, 12, 31, 23, 59,
59)),
'1899:12:31 23:59:59')
self.assertEqual(tag._convert_to_string(datetime.date(1899, 12, 31)),
'1899:12:31 00:00:00')
# Valid values: dates
tag = ExifTag('Exif.GPSInfo.GPSDateStamp')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(tag._convert_to_string(datetime.date(2009, 3, 1)),
'2009:03:01')
self.assertEqual(tag._convert_to_string(datetime.date(1899, 12, 31)),
'1899:12:31')
# Valid values: strings
tag = ExifTag('Exif.Image.Copyright')
self.assertEqual(tag.type, 'Ascii')
self.assertEqual(tag._convert_to_string('Some text'), 'Some text')
self.assertEqual(
tag._convert_to_string('Some text with exotic chàräctérʐ.'),
'Some text with exotic chàräctérʐ.')
def test_pickle_exif_tag(self):
tags = []
tags.append(ExifTag('Exif.Image.DateTime',
datetime.datetime(2010, 12, 22, 19, 21, 0)))
tags.append(ExifTag('Exif.GPSInfo.GPSDateStamp', datetime.date.today()))
tags.append(ExifTag('Exif.Image.Copyright', '(C) 2010 Santa Claus'))
tags.append(ExifTag('Exif.GPSInfo.GPSVersionID', '0'))
tags.append(ExifTag('Exif.Pentax.Temperature', '14'))
tags.append(ExifTag('Exif.Photo.UserComment', 'foo bar baz'))
tags.append(ExifTag('Exif.Image.BitsPerSample', 8))
tags.append(ExifTag('Exif.Image.TimeZoneOffset', 7))
tags.append(ExifTag('Exif.Image.ImageWidth', 7492))
tags.append(ExifTag('Exif.OlympusCs.ManometerReading', 29))
tags.append(ExifTag('Exif.Image.XResolution', make_fraction(7, 3)))
tags.append(ExifTag('Exif.Image.BaselineExposure', make_fraction(-7, 3)))
tags.append(ExifTag('Exif.Photo.ExifVersion', '0100'))
for tag in tags:
s = pickle.dumps(tag)
t = pickle.loads(s)
self.assert_(isinstance(t, ExifTag))
self.assertEqual(t.key, tag.key)
self.assertEqual(t.type, tag.type)
self.assertEqual(t.name, tag.name)
self.assertEqual(t.label, tag.label)
self.assertEqual(t.description, tag.description)
self.assertEqual(t.section_name, tag.section_name)
self.assertEqual(t.section_description, tag.section_description)
self.assertEqual(t.raw_value, tag.raw_value)
self.assertEqual(t.value, tag.value)
self.assertEqual(t.human_value, tag.human_value)
