def test_xmpmeta_str(self):
"""In 2.7, str must return a byte string. In 3.x, it is a str."""
xmp = XMPMeta()
xmp.set_property(NS_DC, "Title", 'Huckleberry Finn')
self.assertTrue(isinstance(str(xmp), str))
xmp = XMPMeta()
xmp.set_property(NS_DC, "Title", u'Stürm und Drang')
self.assertTrue(isinstance(str(xmp), str))
# Something in Devanagari
xmp = XMPMeta()
xmp.set_property(NS_DC, "Title", u'शिव')
self.assertTrue(isinstance(str(xmp), str))
def test_serialize_and_format(self):
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
obj = xmp.serialize_and_format(padding=0,
newlinechr='NEWLINE',
tabchr='TAB',
indent=6)
if sys.hexversion >= 0x03000000:
the_unicode_type = str
else:
the_unicode_type = unicode
self.assertTrue(isinstance(obj, the_unicode_type),
"Result is not the correct string")
with self.assertRaises(XMPError):
xmp.serialize_and_format(read_only_packet=True,
omit_packet_wrapper=True)
with self.assertRaises(XMPError):
xmp.serialize_and_format(include_thumbnail_pad=True,
omit_packet_wrapper=True)
with self.assertRaises(XMPError):
xmp.serialize_and_format(exact_packet_length=True,
omit_packet_wrapper=True)
del xmp
def test_serialize_unicode(self):
"""
Return type is unicode in 2.7, but str in 3.x
"""
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
if sys.hexversion >= 0x03000000:
the_unicode_type = str
else:
the_unicode_type = unicode
obj = xmp.serialize_to_unicode(use_compact_format=True,
omit_packet_wrapper=False)
self.assertTrue(isinstance(obj, the_unicode_type),
"Incorrect string result type.")
with self.assertRaises(XMPError):
xmp.serialize_to_unicode(read_only_packet=True,
omit_packet_wrapper=True)
with self.assertRaises(XMPError):
xmp.serialize_to_unicode(include_thumbnail_pad=True,
omit_packet_wrapper=True)
with self.assertRaises(XMPError):
xmp.serialize_to_unicode(exact_packet_length=True,
omit_packet_wrapper=True)
del xmp
def test_serialize_str(self):
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
obj = xmp.serialize_to_str(use_compact_format=True,
omit_packet_wrapper=True)
if sys.hexversion >= 0x03000000:
the_unicode_type = str
else:
the_unicode_type = unicode
self.assertTrue(isinstance(obj, the_unicode_type))
with self.assertRaises(XMPError):
xmp.serialize_to_str(read_only_packet=True,
omit_packet_wrapper=True)
with self.assertRaises(XMPError):
xmp.serialize_to_str(include_thumbnail_pad=True,
omit_packet_wrapper=True)
with self.assertRaises(XMPError):
xmp.serialize_to_str(exact_packet_length=True,
omit_packet_wrapper=True)
del xmp
def test_parse_from_str_3_bytes_per_codepoint(self):
"""
Verify that we can create and read back utf-8 where each character
takes 3 bytes to encode.
"""
xmp = XMPMeta()
rdf = xmpcoverage.RDFCoverage
# Replace 'Simple2 value' with 'शिव'
# This is 'Shiva' in Devanagari
# शिव has code points [2358, 2367, 2357]
expectedValue = u'शिव'
if sys.hexversion < 0x03000000:
rdf = unicode(rdf[0:272]) + expectedValue + unicode(rdf[285:])
#rdf = rdf[0:272] + expectedValue.encode('utf-8') + rdf[285:]
#rdf = unicode(rdf)
else:
rdf = rdf[0:272] + expectedValue + rdf[285:]
xmp.parse_from_str(rdf, xmpmeta_wrap=True)
prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2")
self.assertEqual(prop, expectedValue)
del xmp
def test_parse_str(self):
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp1")
self.assertEqual(prop, "Simple1 value")
self.assertEqual(prop, u"Simple1 value")
del xmp
def get_xmp_version(filename):
meta = pikepdf.open(filename).open_metadata()
xmp = XMPMeta(xmp_str=str(meta))
try:
return xmp.get_property('http://ns.adobe.com/pdf/1.3/', 'PDFVersion')
except XMPError:
return ''
def test_write_new_property(self):
"""Corresponds to test-write-new-property.cpp"""
filename = pkg_resources.resource_filename(__name__,
"samples/test1.xmp")
with open(filename, 'r') as fptr:
strbuffer = fptr.read()
xmp = XMPMeta()
xmp.parse_from_str(strbuffer, xmpmeta_wrap=False)
XMPMeta.register_namespace(NS_CC, "cc")
reg_prefix = XMPMeta.get_namespace_for_prefix("cc")
self.assertEqual(reg_prefix, NS_CC)
reg_prefix = XMPMeta.get_prefix_for_namespace(NS_CC)
self.assertEqual(reg_prefix, "cc:")
xmp.set_property(NS_CC, "License", "Foo")
self.assertEqual(xmp.get_property(NS_CC, "License"), "Foo")
the_dt = datetime.datetime(2005, 12, 25, 12, 42, 42, tzinfo=pytz.utc)
xmp.set_property_datetime(NS_EXIF, "DateTimeOriginal", the_dt)
self.assertEqual(xmp.get_property(NS_EXIF, "DateTimeOriginal"),
"2005-12-25T12:42:42")
prop = xmp.get_property_datetime(NS_EXIF, "DateTimeOriginal")
self.assertEqual(prop.year, 2005)
self.assertEqual(prop.minute, 42)
self.assertEqual(prop.tzinfo, pytz.utc)
def test_delete_property(self):
"""
Verify the deleting a phony property does not raise an exception.
"""
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
xmp.delete_property(xmpcoverage.NS1, "NotReallyThere")
def test_skip(self):
"""Verify usage of XMPMeta skip method.
"""
filename = pkg_resources.resource_filename(__name__,
"samples/test1.xmp")
with open(filename, 'r') as fptr:
strbuffer = fptr.read()
xmp = XMPMeta()
xmp.parse_from_str(strbuffer)
iterator = iterator = iter(xmp)
schemas = []
paths = []
props = []
for schema, path, prop, options in iterator:
if schema == NS_TIFF:
iterator.skip(iter_skipsubtree=True)
else:
schemas.append(schema)
paths.append(path)
props.append(prop)
# If the iteration modification worked, there should be no TIFF
# properties in the list of schemas.
self.assertTrue(NS_TIFF not in schemas)
self.assertTrue(NS_EXIF in schemas)
def test_delete_property_bad_schema(self):
"""
Specifying a bad schema trigger an exception.
"""
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
with self.assertRaises(XMPError):
xmp.delete_property("not really a schema", "NotReallyThere")
def test_clone(self):
xmp1 = XMPMeta()
self.assertTrue(xmp1 == xmp1, "XMP1 not equal it self")
self.assertFalse(xmp1 != xmp1, "XMP1 is equal it self")
xmp2 = xmp1.clone()
self.assertFalse(xmp1 == xmp2, "XMP1 is not equal XMP2")
self.assertTrue(xmp1 != xmp2, "XMP1 is not equal XMP2")
del xmp1
del xmp2
def test_shorthand_rdf(self):
"""
Tests pass so long as no error is issued.
"""
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.ShorthandRDF, xmpmeta_wrap=True)
prop = xmp.get_property("http://ns.adobe.com/tiff/1.0", "Model")
self.assertEqual(prop, "Canon PowerShot S300")
del xmp
def test_python_xmp_validate_change(sandwich):
with sandwich.open_metadata() as xmp:
assert 'xmp:CreatorTool' in xmp
xmp['xmp:CreatorTool'] = 'Creator' # Exists as a xml tag text
xmp['pdf:Producer'] = 'Producer' # Exists as a tag node
assert str(xmp)
xmpmeta = XMPMeta(xmp_str=str(xmp))
assert xmpmeta.does_property_exist(XMP_NS_XMP, 'CreatorTool')
assert xmpmeta.does_property_exist(XMP_NS_PDF, 'Producer')
def test_text_property_450(self):
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.LongTextProperty, xmpmeta_wrap=True)
headline = xmp.get_property("http://ns.adobe.com/photoshop/1.0/",
'Headline')
self.assertEqual(headline[-5:], "=END=")
self.assertTrue(
len(headline) > 450,
"Not all text was extracted from headline property.")
def test_xmpmeta_unicode_27(self):
"""In 2.7, unicode(xmp) should return a unicode object."""
xmp = XMPMeta()
rdf = xmpcoverage.RDFCoverage
xmp.parse_from_str(rdf)
if sys.hexversion < 0x03000000:
self.assertTrue(isinstance(unicode(xmp), unicode))
else:
# It's a no-op in 3.x.
self.assertTrue(True)
def test_python_xmp_validate_change_list(graph):
with graph.open_metadata() as xmp:
assert 'dc:creator' in xmp
xmp['dc:creator'] = ['Dobby', 'Kreacher']
assert str(xmp)
if not XMPMeta:
pytest.skip(msg='needs libxmp')
xmpmeta = XMPMeta(xmp_str=str(xmp))
DC = XMP_NS_DC
assert xmpmeta.does_array_item_exist(DC, 'creator', 'Dobby')
assert xmpmeta.does_array_item_exist(DC, 'creator', 'Kreacher')
def test_get_localized_text(self):
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2")
self.assertEqual(prop, "Simple2 value")
ltext = xmp.get_localized_text(xmpcoverage.NS1, "ArrayProp2", 'x-one',
'x-one')
self.assertEqual(ltext, "Item2.1 value")
del xmp
def loadXmp(inventory):
for item in inventory:
if 'xmp' in item:
try:
yield (item, object_to_dict(XMPMeta(xmp_str=item['xmp'])))
except OSError:
print("!!!WARN Failed to deserialize XMP data in {}".format(
item['name']))
continue
else:
print(
"!!!WARN: File metadata entry doesn't contain serialized xmp data, ignoring item from categories"
)
def test_count_array_items(self):
"""Tests XMPMeta method count_array_items."""
filename = pkg_resources.resource_filename(__name__,
"samples/test1.xmp")
with open(filename, 'r') as fptr:
strbuffer = fptr.read()
xmp = XMPMeta()
xmp.parse_from_str(strbuffer)
xmp.set_array_item(NS_DC, "creator", 2, "foo")
xmp.append_array_item(NS_DC, "creator", "bar")
xmp.append_array_item(NS_DC, "creator", "donuts")
self.assertEqual(xmp.count_array_items(NS_DC, "creator"), 4)
def get_xmp(self):
"""
Get XMP from file.
:return: A new :class:`libxmp.core.XMPMeta` instance.
:raises XMPError: in case of errors.
"""
xmpptr = _exempi.xmp_files_get_new_xmp(self.xmpfileptr)
_check_for_error()
if xmpptr:
return XMPMeta(_xmp_internal_ref=xmpptr)
else:
return None
def test_does_array_item_exist(self):
"""Tests XMPMeta method does_array_item_exist. Issue #03"""
filename = pkg_resources.resource_filename(__name__,
"samples/test1.xmp")
with open(filename, 'r') as fptr:
strbuffer = fptr.read()
xmp = XMPMeta()
xmp.parse_from_str(strbuffer)
xmp.set_array_item(NS_DC, "creator", 2, "foo")
xmp.append_array_item(NS_DC, "creator", "bar")
self.assertTrue(xmp.does_array_item_exist(NS_DC, "creator", "foo"))
self.assertFalse(xmp.does_array_item_exist(NS_DC, "creator", "blah"))
def test_get_localized_text(self):
"""
Verify that unicode string literals are properly interpreted.
"""
xmp = XMPMeta()
xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True)
prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2")
self.assertEqual(prop, u'Simple2 value')
ltext = xmp.get_localized_text(xmpcoverage.NS1, "ArrayProp2", 'x-one',
'x-one')
self.assertEqual(ltext, u'Item2.1 value')
del xmp
def test_python_xmp_validate_add(trivial):
with trivial.open_metadata() as xmp:
xmp['dc:creator'] = ['Bob', 'Doug']
xmp['dc:title'] = 'Title'
xmp['dc:publisher'] = {'Mackenzie'}
xmp_str = str(xmp).replace('\n', '')
assert '<rdf:Seq><rdf:li>Bob</rdf:li><rdf:li>Doug</rdf:li>' in xmp_str
assert '<rdf:Bag><rdf:li>Mackenzie</rdf:li>' in xmp_str
xmpmeta = XMPMeta(xmp_str=str(xmp))
DC = XMP_NS_DC
assert xmpmeta.does_array_item_exist(DC, 'creator', 'Bob')
assert xmpmeta.does_array_item_exist(DC, 'creator', 'Doug')
assert xmpmeta.get_localized_text(DC, 'title', None, 'x-default') == 'Title'
assert xmpmeta.does_array_item_exist(DC, 'publisher', 'Mackenzie')
def test_cannot_inject_xmp_info_pdf(self):
"""Verify behavior of not being able to inject XMP into barren PDF"""
# See issue 40
srcfile = pkg.resource_filename(__name__,
os.path.join("fixtures", "zeros.pdf"))
with tempfile.NamedTemporaryFile() as tfile:
shutil.copyfile(srcfile, tfile.name)
xmpf = XMPFiles()
xmpf.open_file(tfile.name, open_forupdate=True)
xmp = XMPMeta()
xmp.set_property(NS_PHOTOSHOP, "ICCProfile", "foo")
with self.assertRaises(XMPError):
xmpf.put_xmp(xmp)
xmpf.close_file()
def ocultar_informacion(self, img_name, tag, content):
xmpfile = XMPFiles(file_path=img_name, open_forupdate=True)
tipo = Image.open(img_name).format # Obtenemos el tipo de la imagen.
if tipo == 'JPEG': # Si la imagen es JPEG, almacenamos el contenido en los campos consts.XMP_NS_JPEG
xmp = xmpfile.get_xmp()
xmp.set_property(consts.XMP_NS_JPEG, tag, content)
else: # Si la imagen es PNG
if xmpfile.get_xmp() is None: # Comprobamos si tiene campos XMP, sino, creamos uno vacío.
xmp = XMPMeta()
else: # Si tiene campos XMP, los cogemos.
xmp = xmpfile.get_xmp()
xmp.set_property(consts.XMP_NS_PNG, tag, content) # Almacenamos el contenido en los campos consts.XMP_NS_PNG
xmpfile.put_xmp(xmp)
xmpfile.close_file()
class XMPEmbedderImpl:
def __init__(self):
self._fc = Storage()
def metadata_synch(self, component_id, changes):
# get xmp
# the filename is needed because the extension is unknown, the following line of code is
# tmp code because c.ID will include extension file (not only basename)
# in the new MediaDART release
#print 'MediaDART resource path: ', md_res_path
try:
myxmpfilename = str(self._fc.abspath(component_id))
except Exception, err:
print '\n found some problems getting filename, err: ', err, '\n'
xmpfile = XMPFiles(file_path=myxmpfilename,
open_forupdate=files.XMP_OPEN_FORUPDATE)
xmp = xmpfile.get_xmp()
if not xmp:
xmp = XMPMeta()
for ns in changes.keys():
#print 'Property ', str(i[0]),':', str(i[1])
# first of all check if namespace str(i[0]) and property name str(i[1]) exist
prefix = None
try:
prefix = xmp.get_prefix_for_namespace(str(ns))
except XMPError, err:
print 'Error in get_prefix_for_namespace: ', err
if prefix == None:
#print 'prefix ', prefix[:-1] , ' does not exist.'
try:
log.debug('%s %s' % (str(ns), str(changes[ns]['prefix'])))
res = xmp.register_namespace(
str(ns), str(changes[ns]['prefix'])) # CHANGE ME
#print 'register_namespace gave res = ', res
except XMPError, err:
print 'Error in register_namespace: ', err
def get_img_info(self, filename):
info_filename = filename.split('.')[0] + FileBackend.METADATA_EXTENSION
info_path = os.path.join(FileBackend.METADATA_PATH, info_filename)
# Regenerate the metadata file if it is missing.
if not os.path.isfile(info_path):
info = self.__img_info__(self.__img_path__(filename))
info['filename'] = filename
pickle.dump(info, \
open(os.path.join(FileBackend.METADATA_PATH, info_filename), 'wb'), \
protocol=pickle.HIGHEST_PROTOCOL)
info = pickle.load(open(info_path, 'rb'))
# an XMP object can't be pickled, so we serialize it when saving and
# deserialize it when loading
xmp = XMPMeta()
xmp.parse_from_str(info['xmp'])
info['xmp'] = xmp
return info
def test_can_inject_xmp_info_png(self):
"""Verify behavior of being able to inject XMP into barren PNG"""
# See issue 40
srcfile = pkg.resource_filename(__name__,
os.path.join("fixtures", "zeros.png"))
with tempfile.NamedTemporaryFile() as tfile:
shutil.copyfile(srcfile, tfile.name)
xmpf = XMPFiles()
xmpf.open_file(tfile.name, open_forupdate=True)
xmp = XMPMeta()
xmp.set_property(NS_PHOTOSHOP, "ICCProfile", "foo")
xmpf.put_xmp(xmp)
xmpf.close_file()
xmpf.open_file(tfile.name, usesmarthandler=True)
xmp = xmpf.get_xmp()
prop = xmp.get_property(NS_PHOTOSHOP, "ICCProfile")
xmpf.close_file()
self.assertEqual(prop, "foo")
def test_2bytes_codepoint(self):
"""
Verify that we can create and read back utf-8 where some characters
takes 2 bytes to encode.
"""
xmp = XMPMeta()
rdf = xmpcoverage.RDFCoverage
# Replace 'Simple2 value' with 'stürm'
# ü has code point 252, so takes 5+1=6 bytes to encode.
expectedValue = u'stürm'
if sys.hexversion < 0x03000000:
rdf = unicode(rdf[0:272]) + expectedValue + unicode(rdf[285:])
else:
rdf = rdf[0:272] + expectedValue + rdf[285:]
xmp.parse_from_str(rdf, xmpmeta_wrap=True)
prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2")
self.assertEqual(prop, expectedValue)
del xmp
