Exemple #1
0
    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ʐ.')
Exemple #2
0
 def test_setitem(self):
     self.metadata.read()
     # Set new tags
     key = 'Exif.Photo.ExposureBiasValue'
     tag = ExifTag(key, make_fraction(0, 3))
     self.metadata[key] = tag
     self.failUnless(key in self.metadata._tags['exif'])
     self.failUnlessEqual(self.metadata._tags['exif'][key], tag)
     key = 'Iptc.Application2.City'
     tag = IptcTag(key, ['Barcelona'])
     self.metadata[key] = tag
     self.failUnless(key in self.metadata._tags['iptc'])
     self.failUnlessEqual(self.metadata._tags['iptc'][key], tag)
     key = 'Xmp.dc.description'
     tag = XmpTag(key, {'x-default': 'Sunset picture.'})
     self.metadata[key] = tag
     self.failUnless(key in self.metadata._tags['xmp'])
     self.failUnlessEqual(self.metadata._tags['xmp'][key], tag)
     # Replace existing tags
     key = 'Exif.Photo.ExifVersion'
     tag = ExifTag(key, '0220')
     self.metadata[key] = tag
     self.failUnless(key in self.metadata._tags['exif'])
     self.failUnlessEqual(self.metadata._tags['exif'][key], tag)
     key = 'Iptc.Application2.Caption'
     tag = IptcTag(key, ['Sunset on Barcelona.'])
     self.metadata[key] = tag
     self.failUnless(key in self.metadata._tags['iptc'])
     self.failUnlessEqual(self.metadata._tags['iptc'][key], tag)
     key = 'Xmp.dc.subject'
     tag = XmpTag(key, ['sunset', 'Barcelona', 'beautiful', 'beach'])
     self.metadata[key] = tag
     self.failUnless(key in self.metadata._tags['xmp'])
     self.failUnlessEqual(self.metadata._tags['xmp'][key], tag)
Exemple #3
0
def test_setitem(metadata_ro):
    m = metadata_ro.metadata
    m.read()
    # Set new tags
    key = 'Exif.Photo.ExposureBiasValue'
    tag = ExifTag(key, make_fraction(0, 3))
    m[key] = tag
    assert key in m._tags['exif']
    assert m._tags['exif'][key] == tag
    key = 'Iptc.Application2.City'
    tag = IptcTag(key, ['Barcelona'])
    m[key] = tag
    assert key in m._tags['iptc']
    assert m._tags['iptc'][key] == tag
    key = 'Xmp.dc.description'
    tag = XmpTag(key, {'x-default': 'Sunset picture.'})
    m[key] = tag
    assert key in m._tags['xmp']
    assert m._tags['xmp'][key] == tag
    # Replace existing tags
    key = 'Exif.Photo.ExifVersion'
    tag = ExifTag(key, '0220')
    m[key] = tag
    assert key in m._tags['exif']
    assert m._tags['exif'][key] == tag
    key = 'Iptc.Application2.Caption'
    tag = IptcTag(key, ['Sunset on Barcelona.'])
    m[key] = tag
    assert key in m._tags['iptc']
    assert m._tags['iptc'][key] == tag
    key = 'Xmp.dc.subject'
    tag = XmpTag(key, ['sunset', 'Barcelona', 'beautiful', 'beach'])
    m[key] = tag
    assert key in m._tags['xmp']
    assert m._tags['xmp'][key] == tag
Exemple #4
0
    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])
Exemple #5
0
    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')

        # Invalid values
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3)
Exemple #6
0
    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'), b'13')

        # Invalid values
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
Exemple #7
0
    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'), b'Some text')

        # Invalid values
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
Exemple #8
0
    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')
Exemple #9
0
    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)
Exemple #10
0
 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)
Exemple #11
0
    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)
Exemple #12
0
 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')
Exemple #13
0
    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))
Exemple #14
0
    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)
Exemple #15
0
 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)
Exemple #16
0
    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')
Exemple #17
0
    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)
Exemple #18
0
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)
Exemple #19
0
    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)
Exemple #20
0
    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')
Exemple #21
0
    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')
Exemple #22
0
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
Exemple #23
0
 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)
Exemple #24
0
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)
Exemple #25
0
 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_bytes('charset="%s" déjà vu' % charset),
             'déjà vu')
Exemple #26
0
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)
Exemple #27
0
    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')
Exemple #28
0
    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')
Exemple #29
0
 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)
Exemple #30
0
    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')