Voll funktionsfähiges Beispiel auf GitHub verfügbar:
manage-xmp-in-psd-and-ai-files-python

Einführung

Ein Marketing‑Team legt 400 PSD‑Dateien in Ihre Asset‑Plattform. Der Upload funktioniert. Die Suche nicht, weil keine der Dateien Schlüsselwörter enthält, die Hälfte keinen Urheberrechtshinweis hat und die Designer‑Namen nur in einer irgendwo liegenden Tabelle stehen. Die Lösung ist nicht eine größere Tabelle. XMP‑Verwaltung ist eine GroupDocs.Metadata‑Funktion für Python via .NET, die das Metadaten‑Packet in Photoshop‑PSD‑ und Illustrator‑AI‑Dateien liest und schreibt, sodass Eigentums‑ und Suchdaten in den Dateien selbst leben können.

XMP ist ein XML‑Packet in einem binären Container, organisiert in Schemas: Dublin Core für die Felder, die jedes System versteht, das Photoshop‑Schema für redaktionellen Kontext, XmpBasic für Werkzeug‑Identität. Ein PSD von Hand zu parsen, um zu diesem Packet zu gelangen, ist wirklich schwierig. Mit der Metadata‑Klasse sind es drei Attribut‑Abfragen, und derselbe Code funktioniert für AI‑Dateien.

Dieses Tutorial führt die komplette Rundreise in vier Schritten durch: Schnappschuss des gesamten Pakets, Lesen der relevanten Schemas, Schreiben von Urheberrecht und Ersteller und Markieren von Schlüsselwörtern für die Suche. Jeder Code‑Abschnitt stammt aus einem ausführbaren Repository, das bestätigt, dass die geschriebenen Werte erhalten bleiben.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie haben:

  • Python 3 mit pip
  • GroupDocs.Metadata für Python via .NET (das Repository fixiert Version 26.5)
  • Eine PSD‑ oder AI‑Datei zum Experimentieren

Installation

pip install groupdocs-metadata-net==26.5

Schritt 1 – Schnappschuss des gesamten XMP‑Pakets

Beginnen Sie damit, alles zu sehen, was die Datei trägt. Der Schnappschuss durchläuft das Root‑Packet, jedes registrierte Schema und schließlich den Property‑Tree, um alles Nicht‑Standardmäßige zu erfassen und alles in ein flaches Dict zu sammeln.

result = {}

def put(props, prop):
    value = (str(prop.interpreted_value) if prop.interpreted_value is not None
             else (str(prop.value) if prop.value is not None else ""))
    props[prop.name] = value

with Metadata("campaign-hero.psd") as metadata:
    root = metadata.get_root_package()
    xmp = getattr(root, "xmp_package", None)
    if xmp is not None:
        for p in xmp:                                  # root packet properties
            put(result, p)
        schemes = xmp.schemes
        for scheme in (schemes.dublin_core, schemes.xmp_basic, schemes.photoshop,
                       schemes.camera_raw, schemes.paged_text,
                       schemes.xmp_dynamic_media, schemes.xmp_media_management):
            if scheme is None:
                continue
            for p in scheme:
                put(result, p)
    for p in metadata.find_properties(lambda p: p.name is not None):
        if p.name not in result:                       # catch custom packets
            put(result, p)

Wichtige Punkte:

  • interpreted_value zuerst: Daten und Aufzählungen kommen menschenlesbar statt roh.
  • Sieben Schemas plus ein Sweep: Der abschließende find_properties‑Durchlauf fängt Anbieter‑Pakete ab, die die benannten Schemas übersehen.
  • Eine Datei geöffnet: Der gesamte Schnappschuss kostet einen einzigen Metadata‑Kontext, was bei Massen‑Ingestion wichtig ist.

Tipp: Indexieren Sie dieses Dict zur Ingestionszeit und die meisten späteren Metadatenfragen werden zu Dictionary‑Lookups statt zu Dateilesungen.

Welches XMP‑Schema sollte meine Integration zuerst lesen?

Beginnen Sie mit Dublin Core. Seine neun dc:-Felder tragen Titel, Ersteller, Rechte und Betreff‑Werte, die die meisten DAM‑Systeme, Suchindizes und Lizenz‑Checks gemeinsam nutzen, und sowohl PSD‑ als auch AI‑Dateien stellen sie identisch bereit. Lesen Sie das Photoshop‑Schema als Zweites für redaktionellen Kontext wie City, Credit und DateCreated. Bewahren Sie den vollständigen Paket‑Sweep für Ingestion‑Jobs auf, die alles erfassen müssen.

Schritt 2 – Lesen der Schemas, die echte Fragen beantworten

Für Code zur Anforderungszeit beschränken Sie das Lesen auf ein Schema. Dublin Core beantwortet Eigentums‑ und Suchfragen:

dc_fields = {}
with Metadata("campaign-hero.psd") as metadata:
    xmp = getattr(metadata.get_root_package(), "xmp_package", None)
    dc = xmp.schemes.dublin_core if xmp is not None else None
    if dc is not None:
        for p in dc:
            dc_fields[p.name] = (str(p.interpreted_value)
                                 if p.interpreted_value is not None else
                                 str(p.value) if p.value is not None else "")

print(dc_fields.get("dc:rights", "<no rights recorded>"))

Das Photoshop‑Schema funktioniert auf dieselbe Weise über typisierte Eigenschaften: ps.color_mode, ps.icc_profile, ps.city, ps.country, ps.date_created, ps.caption_writer, ps.credit und ps.source, jeweils mit einer None‑Prüfung gelesen. Das sind die Felder, auf die Bridge, Lightroom und DAM‑Suchfilter bei Adobe‑Dateien setzen.

Beachten Sie, was bei Dateien ohne XMP passiert: Die Prüfungen erzeugen ein leeres Dict, keine Ausnahme. Frisch exportierte Assets machen diesen Fall zur Routine, also behalten Sie dieses Verhalten in Ihrer Integration bei.

Die gleichen drei Lookups funktionieren bei Illustrator‑Dateien. Tauschen Sie campaign-hero.psd gegen brand-mark.ai aus und es ändert sich nichts, was einen einzigen Code‑Pfad für gemischte Adobe‑Archive realistisch macht. In der Praxis kommt ein frisch exportiertes AI‑File häufig mit weniger ausgefüllten Schemas als ein Photoshop‑Save, sodass der leere‑Dict‑Pfad dort öfter durchlaufen wird.

Schritt 3 – Urheberrecht und Ersteller schreiben

Jetzt der Schreib‑Pfad. Das Stempeln von Eigentum berührt drei Felder, sodass jeder Leser dieselbe Identität sieht: dc:rights für den rechtlichen Hinweis, dc:creator als geordnete Liste und xmp:CreatorTool für Werkzeuge, die das XmpBasic‑Schema statt Dublin Core lesen. Ich habe einmal einen Nachmittag damit verloren, dass ein Lizenz‑Banner „Unbekannter Autor“ auf Assets zeigte, die die Designer als getaggt versicherten; die Werte standen in dc:creator, während das Tool nur xmp:CreatorTool las. Das Schreiben beider beendete diese Fehlklasse.

with Metadata("campaign-hero.psd") as metadata:
    root = metadata.get_root_package()
    xmp = getattr(root, "xmp_package", None)
    if xmp is None:                          # file has no XMP at all
        root.xmp_package = XmpPacketWrapper()
        xmp = root.xmp_package
    if xmp.schemes.dublin_core is None:
        xmp.schemes.dublin_core = XmpDublinCorePackage()

    dc = xmp.schemes.dublin_core
    dc.set_rights("(C) 2026 GroupDocs Sample")
    dc.set("dc:creator", XmpArray.from_(["Digital Asset Team"],
                                        XmpArrayType.ORDERED))

    if xmp.schemes.xmp_basic is None:
        xmp.schemes.xmp_basic = XmpBasicPackage()
    xmp.schemes.xmp_basic.creator_tool = "Digital Asset Team"

    metadata.save("campaign-hero-stamped.psd")

Wichtige Punkte:

  • Prüfungen erzeugen fehlende Ebenen: XmpPacketWrapper und XmpDublinCorePackage werden bei Bedarf erstellt, sodass das Schreiben auch bei XMP‑losen Dateien funktioniert.
  • ORDERED‑Array für Ersteller: Die Reihenfolge der Autoren hat Bedeutung, daher verwendet die Ersteller‑Liste ein geordnetes XmpArray.
  • In einen neuen Pfad speichern: Die Quelldatei bleibt unverändert, was die richtige Vorgabe für Export‑Schritte ist.

Schritt 4 – Schlüsselwörter für die Suche markieren

dc:subject ist die Schlüsselwort‑Tasche, die DAM‑Suchindizes verwenden. Das Schreiben ersetzt die gesamte Tasche in einem Aufruf:

with Metadata("campaign-hero.psd") as metadata:
    root = metadata.get_root_package()
    xmp = getattr(root, "xmp_package", None)
    if xmp is None:
        root.xmp_package = XmpPacketWrapper()
        xmp = root.xmp_package
    if xmp.schemes.dublin_core is None:
        xmp.schemes.dublin_core = XmpDublinCorePackage()

    xmp.schemes.dublin_core.set(
        "dc:subject",
        XmpArray.from_(["landscape", "sunset", "commercial"],
                       XmpArrayType.UNORDERED))
    metadata.save("campaign-hero-tagged.psd")

Schlüsselwörter verwenden ein UNORDERED‑Array, weil die Reihenfolge für einen Indexer keine Rolle spielt. Und da set die bestehende Tasche ersetzt, lesen Sie zuerst die aktuellen Schlüsselwörter und mergen sie in Python, wenn Sie additive Tagging‑Vorgänge statt Ersetzung benötigen.

Um ein Schreiben zu verifizieren, führen Sie den Leser aus Schritt 2 erneut gegen die Ausgabedatei aus. Das Repository automatisiert genau das: Es liest seine Ausgaben erneut und prüft, dass der Urheberrechts‑String und das erste Schlüsselwort in den gespeicherten Bytes erhalten bleiben.

Praktische Anwendungen

DAM-Ingestion

Führen Sie den Schnappschuss aus Schritt 1 für jede eingehende Datei aus und speichern Sie das Dict zusammen mit dem Asset‑Datensatz. Suche, Duplikaterkennung und Rechte‑Checks laufen dann gegen Ihre Datenbank statt die Binärdateien erneut zu öffnen. Der Schnappschuss des kleinen Beispiel‑PSDs im Repository liefert bereits einen gesunden Stapel von Eigenschaften in einem Durchlauf, und derselbe Aufruf behält seine Form, wenn die Eingabe zu einem Ordner mit Tausenden wird.

Lizenz‑Durchsetzung

Bevor ein Asset an ein Kunden‑Portal ausgeliefert wird, verlangen Sie ein nicht‑leeres dc:rights. Dateien, die das nicht erfüllen, erhalten automatisch die Behandlung aus Schritt 3, sodass nichts ohne Hinweis das System verlässt.

Batch‑Retagging

Wenn sich die Taxonomie ändert, lesen Sie das dc:subject jeder Datei, mapen alte Begriffe zu neuen in Python und schreiben die zusammengeführte Tasche mit Schritt 4 zurück. Sowohl PSD‑ als auch AI‑Archive nutzen dieselbe Schleife. Kein Photoshop‑Sitz erforderlich.

Best Practices und Tipps

  • Leere als normal behandeln: Dateien ohne XMP sind Routine, keine Fehler; das Early‑Return‑Muster hält Pipelines am Laufen.
  • Vor dem Schreiben von Schlüsselwörtern mergen: set ersetzt dc:subject, also bedeutet additives Tagging: lesen, erweitern, schreiben.
  • Identität in beide Schemas schreiben: Das Paaren von dc:creator mit xmp:CreatorTool hält Dublin Core‑Leser und XmpBasic‑Leser in Übereinstimmung.
  • Schreibvorgänge mit einem Rücklese‑Check verifizieren: Ein erneutes Lesen nach dem Speichern ist günstig und fängt Container‑Überraschungen sofort ab.
  • Lizenz für die Produktion: Der Evaluierungsmodus führt alles gezeigte aus; verwenden Sie eine Lizenz, bevor Sie reale Kunden‑Assets stempeln.

Fazit

Das Lesen und Schreiben von XMP in Adobe‑Dateien reduziert sich auf drei Schritte: Das Packet über get_root_package() auflösen, das benötigte Schema schützen und typisierte Werte lesen oder schreiben. Mit diesen Schritten haben Sie in diesem Tutorial eine komplette Rundreise gebaut, vom Paket‑Schnappschuss über Schema‑Lesen bis hin zu Urheberrechts‑Stempel und Schlüsselwort‑Tagging, mit demselben Code für PSD‑ und AI‑Dateien.

Bereit, das in Ihrem Projekt umzusetzen? Hier sind einige nächste Schritte:

Zusätzliche Ressourcen

Fragen zu Ihrem XMP‑Workflow? Fragen Sie im Support‑Forum.