> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-update-reference-docs-60.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Artifact
export const GitHubLink = ({url, compact = false}) =>
{compact ? "voir la source" : <>
Source GitHub
}
;
## Classe wandb.Artifact
Composant flexible et léger pour la gestion des versions des jeux de données et des modèles.
Créez un W\&B Artifact vide. Remplissez le contenu d’un Artifact avec des méthodes qui
commencent par `add`. Une fois que l’Artifact contient tous les fichiers souhaités, vous pouvez appeler
`run.log_artifact()` pour le journaliser.
```python theme={null}
name: 'str',
type: 'str',
description: 'str | None' = None,
metadata: 'dict[str, Any] | None' = None,
incremental: 'bool' = False,
use_as: 'str | None' = None,
storage_region: 'str | None' = None,
digest_algorithm: "Literal['MD5', 'XXH128']" = 'MD5'
```
## Arguments
Un nom facile à lire pour l'artifact. Utilisez ce nom pour identifier un artifact spécifique dans l'interface de l'application W\&B ou par programmation. Vous pouvez référencer un artifact de manière interactive avec l'API publique `use_artifact`. Un nom peut contenir des lettres, des chiffres, des traits de soulignement, des traits d'union et des points. Le nom doit être unique dans un projet.
Le type de l'artifact. Utilisez le type d'un artifact pour organiser et différencier les Artifacts. Vous pouvez utiliser n'importe quelle chaîne contenant des lettres, des chiffres, des traits de soulignement, des traits d'union et des points. Les types courants incluent `dataset` ou `model`. Incluez `model` dans votre chaîne de type si vous souhaitez lier l'artifact au registre de modèles W\&B. Notez que certains types sont réservés à un usage interne et ne peuvent pas être définis par les utilisateurs. Ces types incluent `job` et les types qui commencent par `wandb-`.
Une description de l'artifact. Pour les Artifacts de type Model ou Dataset, ajoutez la documentation de votre carte de modèle ou de jeu de données standardisée pour l'équipe. Consultez la description d'un artifact par programmation avec l'attribut `Artifact.description` ou dans l'interface de l'application W\&B. W\&B affiche la description au format markdown dans l'application W\&B.
Informations supplémentaires sur un artifact. Spécifiez les métadonnées sous la forme d'un dictionnaire de paires clé-valeur. Vous ne pouvez pas spécifier plus de 100 clés au total.
Utilisez plutôt la méthode `Artifact.new_draft()` pour modifier un artifact existant.
Obsolète.
Aucune description fournie.
L'algorithme de digest à utiliser pour l'artifact. La valeur par défaut est MD5. S'il est défini sur XXH128, l'artifact sera haché à l'aide de l'algorithme XXH128, sauf s'il fait partie d'une collection qui utilise déjà MD5. Les appels à `artifact.verify()` sur des versions du SDK antérieures à 0.29.0 échoueront toujours pour les artifacts XXH128.
## Propriétés
Liste d’une ou plusieurs références explicites sur le plan sémantique ou de
« surnoms » d’identification attribués à une version d’artefact.
Les alias sont des références modifiables auxquelles vous pouvez faire référence par programmation.
Modifiez l’alias d’un artefact dans l’interface de l’application W\&B ou par programmation.
Voir [Créer de nouvelles versions d’artefact](https://docs.wandb.ai/models/artifacts/create-a-new-artifact-version)
pour plus d’informations.
La collection dont cet artefact est issu.
Une collection est un groupe ordonné de versions d’artefact.
Si cet artefact est récupéré depuis une collection à laquelle il est lié,
renvoyer cette collection. Sinon, renvoyer la collection
dont est issue la version d’artefact.
La collection dont est issu un artefact est appelée
séquence source.
Le hachage renvoyé lors de la validation de cet artefact.
Horodatage de création de l’artefact.
Une description de l’artefact.
L’empreinte logique de l’artefact.
L’empreinte est la somme de contrôle du contenu de l’artefact. Si un artefact possède la
même empreinte que la version actuelle `latest`, alors `log_artifact` n’effectue aucune opération.
L’algorithme d’empreinte utilisé pour calculer l’empreinte de l’artefact.
Le nom de l’entité à laquelle appartient la collection d’artefacts.
Si l’artefact est un lien, l’entité sera celle de l’artefact lié.
Le nombre de fichiers, y compris les références.
L’étape la plus proche ayant enregistré des métriques d’historique pour le run source de cet artefact.
L’ID de l’artefact.
Indicateur booléen précisant si l’artefact est un artefact de lien.
True : l’artefact est un artefact de lien vers un artefact source.
False : l’artefact est un artefact source.
Renvoie la liste de tous les artefacts liés à un artefact source.
Si cet artefact est un artefact de lien (`artifact.is_link == True`),
il renvoie une liste vide.
Limité à 500 résultats.
L’heure à laquelle cet artefact a été lié à sa collection actuelle.
Valide uniquement pour les artefacts liés ; renvoie sinon `None`.
Le manifeste de l’artefact.
Le manifeste répertorie tout son contenu et ne peut pas être modifié une fois que l’artefact
a été enregistré.
Métadonnées d’artefact définies par l’utilisateur.
Données structurées associées à l’artefact.
Le nom et la version de l’artefact.
Chaîne au format `{collection}:{alias}`. Si l’artefact est récupéré avant d’être
enregistré/sauvegardé, le nom ne contient pas l’alias.
Si l’artefact est un lien, le nom est celui de l’artefact lié.
Le nom du projet auquel appartient la collection d’artefacts.
Si l’artefact est un lien, le projet est celui de l’artefact lié.
L’entité/le projet/le nom de l’artefact.
Si l’artefact est un lien, le nom qualifié est le nom qualifié du
chemin de l’artefact lié.
La taille totale de l’artefact en octets.
Inclut toutes les références suivies par cet artefact.
Renvoie l’artefact source, c’est-à-dire l’artefact d’origine enregistré.
Si cet artefact est un artefact source (`artifact.is_link == False`),
il se renvoie lui-même.
La collection source de l’artefact.
La collection source est la collection depuis laquelle l’artefact a été enregistré.
Le nom de l’entité de l’artefact source.
Le nom et la version de l’artefact source.
Chaîne au format `{source_collection}:{alias}`. Avant que l’artefact
soit sauvegardé, elle contient uniquement le nom, car la version n’est pas encore connue.
Le nom du projet de l'artifact source.
L'entité source/le projet source/le nom source de l'artifact source.
La version de l'artifact source.
Une chaîne au format `v{number}`.
Le statut de l'artifact. L'un des suivants : "PENDING", "COMMITTED" ou "DELETED".
Liste d'un ou plusieurs tags attribués à cette version d'artifact.
La politique de durée de vie (TTL) d'un artifact.
Les Artifacts sont supprimés peu après l'expiration de la durée définie par une politique TTL.
Si elle est définie sur `None`, l'artifact désactive les politiques TTL et ne sera pas
planifié pour être supprimé, même s'il existe une valeur TTL par défaut pour l'équipe.
Un artifact hérite de la politique TTL par défaut de l'équipe si
l'administrateur de l'équipe définit une valeur TTL par défaut
et qu'aucune politique personnalisée n'est définie sur l'artifact.
Le type de l'artifact. Les types courants incluent `dataset` ou `model`.
L'heure à laquelle l'artifact a été mis à jour pour la dernière fois.
Construit l'URL de l'artifact.
Obsolète.
La version de l'artifact.
Une chaîne au format `v{number}`.
S'il s'agit d'un artifact de lien, la version proviendra de la collection liée.
## Méthodes
### méthode Artifact.add()
```python theme={null}
self,
obj: 'WBValue',
name: 'StrPath',
overwrite: 'bool' = False
```
Ajoute `obj` de type wandb.WBValue à l'artifact.
##### Arguments
L'objet à ajouter. Prend actuellement en charge l'un des types suivants : Bokeh, JoinedTable, PartitionedTable, Table, Classes, ImageMask, BoundingBoxes2D, Audio, Image, Video, Html, Object3D
Le chemin dans l'artifact auquel ajouter l'objet.
Si True, remplace les objets existants ayant le même chemin de fichier, le cas échéant.
##### Exceptions levées
* `ArtifactFinalizedError`: Vous ne pouvez pas modifier la version actuelle de l'artifact, car elle est finalisée. Enregistrez plutôt une nouvelle version de l'artifact.
### méthode Artifact.add\_dir()
```python theme={null}
self,
local_path: 'str',
name: 'str | None' = None,
skip_cache: 'bool | None' = False,
policy: "Literal['mutable', 'immutable'] | None" = 'mutable',
merge: 'bool' = False
```
Ajouter un répertoire local à l'artifact.
##### Arguments
Le chemin du répertoire local.
Le nom du sous-répertoire dans un artifact. Le nom que vous indiquez apparaît dans l'UI de l'application W\&B, sous le `type` de l'artifact. Par défaut, il correspond à la racine de l'artifact.
Si défini sur `True`, W\&B ne copiera ni ne déplacera les fichiers vers le cache pendant l'upload
Par défaut, "mutable".
* mutable: Crée une copie temporaire du fichier pour éviter
toute corruption pendant l'upload.
* immutable: Désactive la protection et suppose que l'utilisateur ne supprimera ni ne modifiera le fichier.
Si `False` (par défaut), lève une ValueError si un fichier a déjà été ajouté lors d'un précédent appel à add\_dir et que son contenu a changé. Si `True`, écrase les fichiers existants dont le contenu a changé. Ajoute toujours les nouveaux fichiers et ne supprime jamais de fichiers. Pour remplacer un répertoire entier, passez un nom lors de l'ajout du répertoire avec `add_dir(local_path, name=my_prefix)` et appelez `remove(my_prefix)` pour supprimer le répertoire, puis ajoutez-le de nouveau.
##### Exceptions levées
* `ArtifactFinalizedError`: Vous ne pouvez pas modifier la version actuelle de l'artifact, car elle est finalisée. Créez plutôt une nouvelle version de l'artifact.
* `ValueError`: La stratégie doit être "mutable" ou "immutable"
### méthode Artifact.add\_file()
```python theme={null}
self,
local_path: 'str',
name: 'str | None' = None,
is_tmp: 'bool | None' = False,
skip_cache: 'bool | None' = False,
policy: "Literal['mutable', 'immutable'] | None" = 'mutable',
overwrite: 'bool' = False
```
Ajoutez un fichier local à l'artifact.
##### Arguments
Le chemin du fichier à ajouter.
Le chemin à utiliser dans l'artifact pour le fichier ajouté. La valeur par défaut est le nom de base du fichier.
Si la valeur est true, le fichier est renommé de manière déterministe pour éviter les collisions.
Si la valeur est `True`, ne copiez pas les fichiers dans le cache après le téléversement.
Par défaut, la valeur est définie sur "mutable". Si elle est définie sur "mutable", créez une copie temporaire du fichier pour éviter toute corruption pendant le téléversement. Si elle est définie sur "immutable", désactivez la protection et supposez que l'utilisateur ne supprimera pas et ne modifiera pas le fichier.
Si la valeur est `True`, remplacez le fichier s'il existe déjà.
##### Exceptions levées
* `ArtifactFinalizedError`: Vous ne pouvez pas modifier la version actuelle de l'artifact, car elle est finalisée. Créez plutôt une nouvelle version de l'artifact.
* `ValueError`: La stratégie doit être "mutable" ou "immutable"
### méthode Artifact.add\_reference()
```python theme={null}
self,
uri: 'ArtifactManifestEntry | str',
name: 'StrPath | None' = None,
checksum: 'bool' = True,
max_objects: 'int | None' = None
```
Ajoutez à l'artifact une référence désignée par un URI.
Contrairement aux fichiers ou répertoires que vous ajoutez à un artifact, les références ne sont pas téléversées vers W\&B. Pour plus d'informations, voir [Suivre des fichiers externes](https://docs.wandb.ai/models/artifacts/track-external-files).
Par défaut, les schémas suivants sont pris en charge :
* http(s) : la taille et le digest du fichier sont déduites des en-têtes de réponse `Content-Length` et `ETag` renvoyés par le serveur.
* s3 : la somme de contrôle et la taille sont récupérées à partir des métadonnées de l'objet. Si la gestion des versions du bucket est activée, l'ID de version est également suivi.
* gs : la somme de contrôle et la taille sont récupérées à partir des métadonnées de l'objet. Si la gestion des versions du bucket est activée, l'ID de version est également suivi.
* https, domaine correspondant à `*.blob.core.windows.net`
* Azure : la somme de contrôle et la taille sont récupérées à partir des métadonnées du blob. Si la gestion des versions du compte de stockage est activée, l'ID de version est également suivi.
* file : la somme de contrôle et la taille sont récupérées à partir du système de fichiers. Ce schéma est utile si vous avez un partage NFS ou un autre volume monté en externe contenant des fichiers que vous souhaitez suivre sans nécessairement les téléverser.
Pour tout autre schéma, le digest est simplement un hachage de l'URI et la taille reste vide.
##### Arguments
le chemin URI de la référence à ajouter. Le chemin URI peut être un objet renvoyé par `Artifact.get_entry` pour stocker une référence vers l'entrée d'un autre artifact.
le chemin au sein de l'artifact où placer le contenu de cette référence.
indique s'il faut calculer ou non une somme de contrôle pour la ou les ressources situées à l'URI de référence. Le calcul de la somme de contrôle est fortement recommandé, car il permet une validation automatique de l'intégrité. Le désactiver accélère la création de l'artifact, mais les répertoires de référence ne seront pas parcourus, de sorte que les objets du répertoire ne seront pas enregistrés dans l'artifact. Nous vous recommandons de définir `checksum=False` lors de l'ajout d'objets de référence ; dans ce cas, une nouvelle version ne sera créée que si l'URI de référence change.
le nombre maximal d'objets à prendre en compte lors de l'ajout d'une référence pointant vers un répertoire ou un préfixe de stockage de bucket. Par défaut, le nombre maximal d'objets autorisé pour Amazon S3, GCS, Azure et les fichiers locaux est de 10,000,000. Les autres schémas d'URI n'ont pas de limite.
##### Exceptions levées
* `ArtifactFinalizedError`: Vous ne pouvez pas modifier la version actuelle de l'artifact, car elle est finalisée. Enregistrez plutôt une nouvelle version de l'artifact.
### méthode Artifact.checkout()
```python theme={null}
self,
root: 'str | None' = None
```
Remplace le répertoire racine spécifié par le contenu de l'artifact.
AVERTISSEMENT : cette opération supprimera tous les fichiers dans `root` qui ne sont pas inclus dans l'artifact.
##### Arguments
le répertoire à remplacer par les fichiers de cet artifact.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.delete()
```python theme={null}
self,
delete_aliases: 'bool' = False
```
Supprime un artifact et ses fichiers.
Si cette méthode est appelée sur un artifact lié, seul le lien est supprimé, et l’artifact source n’est pas affecté.
Utilisez `Artifact.unlink()` au lieu de `Artifact.delete()` pour supprimer le lien entre un artifact source et une collection.
##### Arguments
Si défini sur `True`, supprime tous les alias associés à l’artifact. Si `False`, lève une exception si l’artifact possède déjà des alias. Ce paramètre est ignoré si l’artifact est récupéré depuis une collection à laquelle il est lié.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.download()
```python theme={null}
self,
root: 'StrPath | None' = None,
allow_missing_references: 'bool' = False,
skip_cache: 'bool | None' = None,
path_prefix: 'StrPath | None' = None,
multipart: 'bool | None' = None
```
Télécharge le contenu de l'artifact dans le répertoire racine spécifié.
Les fichiers existants dans `root` ne sont pas modifiés. Supprimez explicitement `root`
avant d'appeler `download` si vous voulez que son contenu corresponde exactement à celui de l'artifact.
##### Arguments
Le répertoire dans lequel W\&B stocke les fichiers de l'artifact.
Si défini sur `True`, tous les chemins de référence invalides seront ignorés lors du téléchargement des fichiers référencés.
Si défini sur `True`, le cache de l'artifact sera ignoré lors du téléchargement, et W\&B téléchargera chaque fichier dans le répertoire racine par défaut ou dans le répertoire de téléchargement spécifié.
Si spécifié, seuls les fichiers dont le chemin commence par le préfixe indiqué seront téléchargés. Utilise le format Unix (barres obliques `/`).
Si défini sur `None` (par défaut), l'artifact sera téléchargé en parallèle à l'aide d'un téléchargement multipart si la taille d'un fichier individuel dépasse 2 Go. Si défini sur `True` ou `False`, l'artifact sera téléchargé en parallèle ou en série, quelle que soit la taille du fichier.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.file()
```python theme={null}
self,
root: 'str | None' = None
```
Télécharge un artifact contenant un seul fichier dans le répertoire spécifié par `root`.
##### Arguments
Le répertoire racine dans lequel stocker le fichier. Valeur par défaut : `./artifacts/self.name/`.
##### Exceptions levées
* `ArtifactNotLoggedError` : Si l'artifact n'est pas enregistré.
* `ValueError` : Si l'artifact contient plus d'un fichier.
### méthode Artifact.files()
```python theme={null}
self,
names: 'list[str] | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
```
Parcourez tous les fichiers stockés dans cet artifact.
##### Arguments
Les chemins des fichiers, relatifs à la racine de l'artifact, que vous souhaitez lister.
Le nombre de fichiers à renvoyer par requête.
Curseur de pagination pour reprendre une requête précédente, capturé à partir de l’attribut `.cursor` d’un paginateur précédent.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.finalize()
```python theme={null}
self
```
Finalisez la version de l'artifact.
Vous ne pouvez pas modifier une version d'artifact une fois qu'elle est finalisée, car l'artifact
est journalisé en tant que version d'artifact spécifique. Créez une nouvelle version d'artifact
pour y journaliser davantage de données. Un artifact est automatiquement finalisé
lorsque vous le journalisez avec `log_artifact`.
### méthode Artifact.get()
```python theme={null}
self,
name: 'str'
```
Obtient l'objet WBValue situé à l'emplacement relatif `name` dans l'artifact.
##### Arguments
Le nom relatif dans l'artifact à récupérer.
##### Exceptions levées
* `ArtifactNotLoggedError`: si l’artifact n’est pas enregistré ou si le run est hors ligne.
### méthode Artifact.get\_added\_local\_path\_name()
```python theme={null}
self,
local_path: 'str'
```
Obtenir le nom relatif dans l'artifact d’un fichier ajouté à partir d’un chemin local du système de fichiers.
##### Arguments
Le chemin local à convertir en nom relatif dans l'artifact.
### méthode Artifact.get\_entry()
```python theme={null}
self,
name: 'StrPath'
```
Récupère l’entrée portant le nom indiqué.
##### Arguments
Le nom relatif de l’artifact à récupérer
##### Exceptions levées
* `ArtifactNotLoggedError`: si l’artifact n’est pas enregistré ou si le run est hors ligne.
* `KeyError`: si l’artifact ne contient pas d’entrée portant le nom indiqué.
### méthode Artifact.get\_path()
```python theme={null}
self,
name: 'StrPath'
```
Obsolète. Utilisez `get_entry(name)`.
##### Arguments
Aucune description fournie.
### méthode Artifact.is\_draft()
```python theme={null}
self
```
Vérifie si l’artifact n’est pas enregistré.
### méthode Artifact.json\_encode()
```python theme={null}
self
```
Retourne l'artifact encodé au format JSON.
### méthode Artifact.link()
```python theme={null}
self,
target_path: 'str',
aliases: 'Iterable[str] | None' = None
```
Liez cet artifact à une collection.
##### Arguments
Chemin de la collection. Il se compose du préfixe "wandb-registry-", ainsi que du nom du registre et du nom de la collection : `wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}`.
Ajoutez un ou plusieurs alias à l'artifact lié. L'alias "latest" est automatiquement appliqué à l'artifact le plus récent que vous liez.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.logged\_by()
```python theme={null}
self
```
Obtient le run W\&B qui a enregistré l'artifact à l'origine.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.new\_draft()
```python theme={null}
self
```
Créez un nouvel artifact brouillon avec le même contenu que cet artifact validé.
La modification d’un artifact existant crée une nouvelle version d’artifact appelée « artifact incrémentiel ». L’artifact renvoyé peut être enrichi ou modifié, puis enregistré comme nouvelle version.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.new\_file()
```python theme={null}
self,
name: 'str',
mode: 'str' = 'x',
encoding: 'str | None' = None,
policy: "Literal['mutable', 'immutable']" = 'mutable'
```
Ouvrez un nouveau fichier temporaire et ajoutez-le à l'artifact.
##### Arguments
Le nom du nouveau fichier à ajouter à l'artifact.
Le mode d'accès à utiliser pour ouvrir le nouveau fichier.
L'encodage utilisé pour ouvrir le nouveau fichier.
Par défaut, la valeur est définie sur "mutable". Si elle est définie sur "mutable", créez une copie temporaire du fichier pour éviter toute corruption pendant le téléversement. Si elle est définie sur "immutable", désactivez la protection et supposez que l'utilisateur ne supprimera pas et ne modifiera pas le fichier.
##### Exceptions levées
* `ArtifactFinalizedError`: Vous ne pouvez pas modifier la version actuelle de l'artifact, car elle est finalisée. Enregistrez plutôt une nouvelle version de l'artifact.
### méthode Artifact.remove()
```python theme={null}
self,
item: 'StrPath | ArtifactManifestEntry'
```
Supprime un élément de l'artifact.
##### Arguments
Élément à supprimer. Il peut s'agir d'une entrée de manifeste spécifique ou du nom d'un chemin relatif à l'artifact. Si l'élément correspond à un répertoire, tous les éléments de ce répertoire seront supprimés.
##### Exceptions levées
* `ArtifactFinalizedError`: Vous ne pouvez pas modifier la version actuelle de l'artifact, car elle est finalisée. Enregistrez plutôt une nouvelle version de l'artifact.
* `FileNotFoundError`: Si l'élément est introuvable dans l'artifact.
### méthode Artifact.save()
```python theme={null}
self,
project: 'str | None' = None,
settings: 'wandb.Settings | None' = None
```
Enregistrez toutes les modifications apportées à l'artifact.
Si vous êtes actuellement dans un run, ce run journalisera cet artifact. Sinon, un run de type "auto" est créé pour suivre cet artifact.
##### Arguments
Projet à utiliser pour l'artifact si aucun run n'est déjà actif dans le contexte.
Objet de paramètres à utiliser lors de l'initialisation d'un run automatique. Principalement utilisé dans une infrastructure de test.
### méthode Artifact.unlink()
```python theme={null}
self
```
Dissociez cet artifact s'il est lié en tant que membre d'une collection d'artifacts.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
* `ValueError`: Si l’artifact n’est pas lié à aucune collection.
### méthode Artifact.used\_by()
```python theme={null}
self
```
Obtenir la liste des runs ayant utilisé cet artifact et les artifacts qui lui sont liés.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
### méthode Artifact.verify()
```python theme={null}
self,
root: 'str | None' = None
```
Vérifier que le contenu d’un artifact correspond au manifeste.
Une somme de contrôle est calculée pour tous les fichiers du répertoire, puis ces sommes sont
comparées à celles du manifeste de l’artifact. Les références ne sont pas vérifiées.
##### Arguments
Le répertoire à vérifier. Si `None`, l’artifact sera téléchargé dans './artifacts/self.name/'.
##### Exceptions levées
* `ArtifactNotLoggedError`: Si l’artifact n’est pas enregistré.
* `ValueError`: Si la vérification échoue.
### méthode Artifact.wait()
```python theme={null}
self,
timeout: 'int | None' = None
```
Si nécessaire, attendez que cet artifact ait fini d’être enregistré.