Exemple complet disponible sur GitHub :
manage-xmp-in-psd-and-ai-files-python

Introduction

Une équipe marketing dépose 400 fichiers PSD sur votre plateforme d’actifs. Le téléchargement fonctionne. La recherche ne fonctionne pas, car aucun des fichiers ne comporte de mots‑clés, la moitié n’a pas de mention de droit d’auteur, et les noms des designers ne vivent que dans un tableau quelque part. La solution n’est pas un tableau plus gros. La gestion XMP est une fonctionnalité de GroupDocs.Metadata pour Python via .NET qui lit et écrit le paquet de métadonnées intégré dans les fichiers Photoshop PSD et Illustrator AI, ce qui signifie que la propriété et les données de recherche peuvent vivre dans les fichiers eux‑mêmes.

XMP est un paquet XML à l’intérieur d’un conteneur binaire, organisé en schémas : Dublin Core pour les champs compris par tous les systèmes, le schéma Photoshop pour le contexte éditorial, XmpBasic pour l’identité de l’outil. Analyser manuellement un PSD afin d’atteindre ce paquet est réellement difficile. Avec la classe Metadata, il ne s’agit que de trois recherches d’attributs, et le même code sert les fichiers AI.

Ce tutoriel parcourt le cycle complet en quatre étapes : prendre un instantané du paquet complet, lire les schémas pertinents, écrire le droit d’auteur et le créateur, et ajouter des mots‑clés pour la recherche. Chaque extrait provient d’un dépôt exécutable qui vérifie que les valeurs écrites persistent.

Prérequis

Avant de commencer, assurez‑vous d’avoir :

  • Python 3 avec pip
  • GroupDocs.Metadata pour Python via .NET (le dépôt fixe la version 26.5)
  • Un fichier PSD ou AI pour expérimenter

Installation

pip install groupdocs-metadata-net==26.5

Étape 1 – Instantané du paquet XMP complet

Commencez par voir tout ce que le fichier transporte. L’instantané parcourt le paquet racine, chaque schéma enregistré, puis balaie l’arbre des propriétés pour tout ce qui n’est pas standard, en tout rassemblant le tout dans un dictionnaire plat.

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:                                  # propriétés du paquet racine
            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:                       # attraper les paquets personnalisés
            put(result, p)

Points clés :

  • interpreted_value en premier : les dates et les énumérations arrivent lisibles par l’homme au lieu de brutes.
  • Sept schémas plus un balayage : le passage final find_properties capture les paquets fournisseurs que les schémas nommés manquent.
  • Un seul fichier ouvert : l’ensemble de l’instantané ne coûte qu’un seul contexte Metadata, ce qui compte lors d’une ingestion massive.

Astuce : indexez ce dictionnaire au moment de l’ingestion et la plupart des questions de métadonnées ultérieures deviennent des recherches dans le dictionnaire plutôt que des lectures de fichiers.

Quel schéma XMP mon intégration doit‑elle lire en premier ?

Commencez par Dublin Core. Ses neuf champs dc: contiennent le titre, le créateur, les droits et le sujet que la plupart des systèmes DAM, des index de recherche et des contrôles de licence utilisent, et les fichiers PSD et AI les exposent de façon identique. Lisez le schéma Photoshop ensuite pour le contexte éditorial tel que City, Credit et DateCreated. Réservez le balayage complet du paquet aux travaux d’ingestion qui doivent tout capturer.

Étape 2 – Lire les schémas qui répondent aux vraies questions

Pour le code exécuté à la demande, limitez la lecture à un seul schéma. Dublin Core répond aux questions de propriété et de recherche :

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>"))

Le schéma Photoshop fonctionne de la même façon via des propriétés typées : ps.color_mode, ps.icc_profile, ps.city, ps.country, ps.date_created, ps.caption_writer, ps.credit et ps.source, chacune lue avec une protection None. Ce sont les champs sur lesquels Bridge, Lightroom et les filtres de recherche DAM s’appuient pour les fichiers Adobe.

Notez ce qui se passe avec les fichiers dépourvus de XMP : les protections renvoient un dictionnaire vide, pas d’exception. Les actifs fraîchement exportés rendent ce cas fréquent, donc conservez ce comportement dans votre intégration.

Les mêmes trois lectures fonctionnent sur les fichiers Illustrator. Remplacez campaign-hero.psd par brand-mark.ai et rien d’autre ne change, ce qui rend un chemin de code unique réaliste pour des archives Adobe mixtes. En pratique, une exportation AI fraîche tend à contenir moins de schémas remplis qu’une sauvegarde Photoshop, donc le chemin du dictionnaire vide est exercé plus souvent là‑bas.

Étape 3 – Écrire le droit d’auteur et le créateur

Passons maintenant à l’écriture. L’apposition de propriété touche trois champs afin que chaque lecteur voie la même identité : dc:rights pour la mention légale, dc:creator comme liste ordonnée, et xmp:CreatorTool pour les outils qui lisent le schéma XmpBasic au lieu de Dublin Core. J’ai autrefois perdu un après‑midi à cause d’une bannière de licence affichant « Auteur inconnu » sur des actifs que les designers affirmaient être étiquetés ; les valeurs étaient dans dc:creator tandis que l’outil ne lisait que xmp:CreatorTool. Écrire les deux a résolu ce type de bug.

with Metadata("campaign-hero.psd") as metadata:
    root = metadata.get_root_package()
    xmp = getattr(root, "xmp_package", None)
    if xmp is None:                          # le fichier n’a aucun XMP
        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")

Points clés :

  • Les protections créent les couches manquantes : XmpPacketWrapper et XmpDublinCorePackage sont créés à la demande, donc l’écriture fonctionne même sur des fichiers sans XMP.
  • Tableau ORDERED pour les créateurs : l’ordre des auteurs a du sens, d’où l’utilisation d’un XmpArray ordonné.
  • Enregistrez vers un nouveau chemin : le fichier source reste intact, ce qui est le comportement par défaut approprié pour les étapes d’exportation.

Étape 4 – Ajouter des mots‑clés pour la recherche

dc:subject est le sac de mots‑clés des index de recherche DAM. L’écriture remplace le sac complet en un seul appel :

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")

Les mots‑clés utilisent un tableau UNORDERED car l’ordre n’a aucune importance pour un indexeur. Et comme set remplace le sac existant, lisez d’abord les mots‑clés actuels et fusionnez‑les en Python lorsque vous avez besoin d’un ajout plutôt que d’un remplacement.

Pour vérifier une écriture, relancez le lecteur de l’Étape 2 sur le fichier de sortie. Le dépôt automatise exactement cela : il relit ses sorties et affirme que la chaîne de droit d’auteur et le premier mot‑clé survivent dans les octets enregistrés.

Applications réelles

Ingestion DAM

Exécutez l’instantané de l’Étape 1 sur chaque fichier entrant et stockez le dictionnaire à côté de l’enregistrement d’actif. La recherche, la déduplication et les vérifications de droits s’exécutent alors contre votre base de données au lieu de rouvrir les fichiers binaires. L’instantané du petit PSD d’exemple du dépôt renvoie déjà un ensemble conséquent de propriétés en un seul passage, et le même appel conserve sa forme lorsque l’entrée devient un dossier de milliers de fichiers.

Application de licences

Avant qu’un actif ne soit envoyé à un portail client, exigez un dc:rights non vide. Les fichiers qui échouent reçoivent automatiquement le traitement d’apposition de l’Étape 3, ainsi rien ne quitte le système sans mention.

Retagging par lots

Lorsque la taxonomie change, lisez le dc:subject de chaque fichier, mappez les anciens termes vers les nouveaux en Python, puis écrivez le sac fusionné avec l’Étape 4. Les archives PSD et AI utilisent la même boucle. Aucun poste Photoshop n’est requis.

Bonnes pratiques et astuces

  • Traitez le vide comme normal : les fichiers sans XMP sont courants, pas des erreurs ; le schéma de retour anticipé maintient les pipelines fluides.
  • Fusionnez avant d’écrire les mots‑clés : set remplace dc:subject, donc le marquage additif implique lecture, extension, écriture.
  • Écrivez l’identité dans les deux schémas : associer dc:creator à xmp:CreatorTool garde les lecteurs Dublin Core et XmpBasic en accord.
  • Vérifiez les écritures avec une relecture : une relecture après sauvegarde est peu coûteuse et détecte immédiatement les surprises du conteneur.
  • Licence pour la production : le mode d’évaluation exécute tout ce qui est montré ici ; utilisez une licence avant d’apposer des actifs réels de clients.

Conclusion

Lire et écrire le XMP dans les fichiers Adobe se résume à trois actions : résoudre le paquet via get_root_package(), protéger le schéma dont vous avez besoin, et lire ou écrire les valeurs typées. Avec ces actions vous avez construit un cycle complet dans ce tutoriel, de l’instantané du paquet aux lectures de schémas, en passant par l’apposition de droit d’auteur et le marquage de mots‑clés, avec le même code servant les fichiers PSD et AI.

Prêt à implémenter cela dans votre projet ? Voici les prochaines étapes :

Ressources supplémentaires

Des questions sur votre flux de travail XMP ? Demandez sur le support forum.