> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-locadex-parallel-t9n-main-cs60c8p4o6ik99tylxgp3.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Api
export const GitHubLink = ({url}) =>
Source GitHub
;
## classe wandb.Api
```python theme={null}
overrides: 'dict[str, Any] | None' = None,
timeout: 'int | None' = None,
api_key: 'str | None' = None
```
Utilisé pour envoyer des requêtes au serveur W\&B.
## Arguments
* `overrides` : vous pouvez définir `base_url` si vous utilisez un serveur W\&B autre que `https://api.wandb.ai`. Vous pouvez également définir des valeurs par défaut pour `entity`, `project` et `run`.
* `timeout` : délai d’expiration HTTP en secondes pour les requêtes API. S’il n’est pas spécifié, le délai d’expiration par défaut sera utilisé.
* `api_key` : clé API à utiliser pour l’authentification. Si elle n’est pas fournie, la clé API de l’Environnement actuel ou de la configuration sera utilisée. Demande une clé API si aucune n’est fournie ou configurée dans l’Environnement.
## Exemples
```python theme={null}
import wandb
wandb.Api()
```
## Propriétés
### propriété default\_entity
Renvoie l’entité W\&B par défaut.
### propriété user\_agent
Renvoie l’agent utilisateur public de W\&B.
### propriété viewer
Renvoie l’objet viewer.
* `name`: Le nom de l'artifact. Le nom d'un artifact ressemble à un chemin de fichier qui contient, au minimum, le nom du projet dans lequel l'artifact a été enregistré, le nom de l'artifact, ainsi que la version ou l'alias de l'artifact. Vous pouvez éventuellement ajouter en préfixe l'entité qui a enregistré l'artifact, suivie d'une barre oblique. Si aucune entité n'est spécifiée dans le nom, l'entité du run ou du paramètre de l'API est utilisée.
* `type`: Le type d'artifact à récupérer.
##### Exceptions levées
* `ValueError`: Si le nom de l'artifact n'est pas spécifié.
* `ValueError`: Si le type d'artifact est spécifié, mais ne correspond pas au type de l'artifact récupéré.
##### Exemples
Dans les extraits de code suivants, « entity », « project », « artifact »,
« version » et « alias » sont des espaces réservés pour votre entité W\&B, le nom
du projet dans lequel se trouve l'artifact, le nom de l'artifact
et la version de l'artifact, respectivement.
```python theme={null}
import wandb
# Spécifier le projet, le nom de l'artifact et l'alias de l'artifact
wandb.Api().artifact(name="project/artifact:alias")
# Spécifier le projet, le nom de l'artifact et une version spécifique de l'artifact
wandb.Api().artifact(name="project/artifact:version")
# Spécifier l'entité, le projet, le nom de l'artifact et l'alias de l'artifact
wandb.Api().artifact(name="entity/project/artifact:alias")
# Spécifier l'entité, le projet, le nom de l'artifact et une version spécifique de l'artifact
wandb.Api().artifact(name="entity/project/artifact:version")
```
### méthode Api.artifact\_collection()
```python theme={null}
self,
type_name: 'str',
name: 'str'
```
Renvoie une collection d'artifacts pour un type donné.
Vous pouvez utiliser l'objet `ArtifactCollection` renvoyé pour récupérer
des informations sur des artifacts spécifiques dans cette collection, entre autres.
##### Arguments
* `type_name`: Le type de collection d'artifacts à récupérer.
* `name`: Un nom de collection d'artifacts. Vous pouvez éventuellement faire précéder ce nom de l'entité qui a enregistré l'artifact, suivie d'une barre oblique.
##### Exemples
Dans l'extrait de code ci-après, "type", "entity", "project" et "artifact\_name" sont des valeurs fictives représentant respectivement le type de collection, votre entité W\&B, le nom du projet dans lequel se trouve l'artifact et le nom de l'artifact.
```python theme={null}
import wandb
collections = wandb.Api().artifact_collection(
type_name="type", name="entity/project/artifact_name"
)
# Obtenir le premier artifact de la collection
artifact_example = collections.artifacts()[0]
# Télécharger le contenu de l'artifact dans le répertoire racine spécifié.
artifact_example.download()
```
### méthode Api.artifact\_collection\_exists()
```python theme={null}
self,
name: 'str',
type: 'str'
```
Indique si une collection d'artifacts existe dans un projet et une entité spécifiés.
##### Arguments
* `name`: Nom d'une collection d'artifacts. Vous pouvez éventuellement ajouter comme préfixe l'entité qui a enregistré l'artifact, suivie d'une barre oblique. Si l'entité ou le projet n'est pas spécifié, déduisez la collection à partir des paramètres de substitution, s'ils existent. Sinon, l'entité est récupérée depuis les Paramètres utilisateur et le projet prendra par défaut la valeur "uncategorized".
* `type`: Le type de la collection d'artifacts.
##### Exemples :
Dans l'extrait de code ci-après, "type" et "collection\_name" désignent respectivement le type de la collection d'artifacts et le nom de la collection.
```python theme={null}
import wandb
wandb.Api.artifact_collection_exists(type="type", name="collection_name")
```
### méthode Api.artifact\_collections()
```python theme={null}
self,
project_name: 'str',
type_name: 'str',
order: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie une collection de collections d'artifacts correspondantes.
##### Arguments
* `project_name`: Le nom du projet à utiliser pour le filtrage.
* `type_name`: Le nom du type d'artifact à utiliser pour le filtrage.
* `order`: Chaîne facultative permettant de spécifier l'ordre des résultats. Si elle est préfixée par '+', le tri est croissant (par défaut). Si elle est préfixée par '-', le tri est décroissant.
* `per_page`: Définit le nombre d'éléments par page pour la pagination de la requête. En général, il n'est pas nécessaire de modifier cette valeur.
* `start`: Curseur de pagination pour reprendre une requête précédente, capturé à partir de l'attribut `.cursor` d'un paginateur précédent.
### méthode Api.artifact\_exists()
```python theme={null}
self,
name: 'str',
type: 'str | None' = None
```
Indique si une version d'artifact existe dans le projet et l'entité spécifiés.
##### Arguments
* `name`: Le nom de l'artifact. Ajoutez l'entité et le projet de l'artifact en préfixe. Ajoutez la version ou l'alias de l'artifact après un deux-points. Si l'entité ou le projet n'est pas spécifié, W\&B utilise les paramètres d'override s'ils sont renseignés. Sinon, l'entité est récupérée à partir des paramètres utilisateur et le projet est défini sur "Uncategorized".
* `type`: Le type d'artifact.
##### Exemples
Dans les extraits de code qui suivent, "entity", "project", "artifact",
"version" et "alias" sont des espaces réservés pour votre entité W\&B, le nom du
projet dans lequel se trouve l'artifact, le nom de l'artifact et la
version de l'artifact, respectivement.
```python theme={null}
import wandb
wandb.Api().artifact_exists("entity/project/artifact:version")
wandb.Api().artifact_exists("entity/project/artifact:alias")
```
### méthode Api.artifact\_type()
```python theme={null}
self,
type_name: 'str',
project: 'str | None' = None
```
Renvoie l'`ArtifactType` correspondant.
##### Arguments
* `type_name`: Le nom du type d'artifact à récupérer.
* `project`: Si fourni, le nom d'un projet ou un chemin à utiliser comme filtre.
### méthode Api.artifact\_types()
```python theme={null}
self,
project: 'str | None' = None,
start: 'str | None' = None
```
Renvoie une collection de types d'artifact correspondants.
##### Arguments
* `project` : Le nom du projet ou le chemin à utiliser pour le filtrage.
* `start` : Curseur de pagination pour reprendre une requête précédente, capturé depuis l’attribut `.cursor` d’un paginateur précédent.
### méthode Api.artifact\_versions()
```python theme={null}
(self, type_name, name, per_page=50)
```
Obsolète. Utilisez la méthode `Api.artifacts(type_name, name)` à la place.
* `type_name`: Le type d'artifacts à récupérer.
* `name`: Le nom de la collection de l'artifact. Vous pouvez éventuellement faire précéder ce nom de l'entité qui a enregistré l'artifact, suivie d'une barre oblique.
* `order`: Chaîne facultative permettant de spécifier l'ordre des résultats. Si elle est préfixée par '+', le tri est croissant (par défaut). Si elle est préfixée par '-', le tri est décroissant.
* `per_page`: Définit la taille de page pour la pagination des requêtes. En général, il n'y a aucune raison de modifier ce paramètre.
* `tags`: Renvoie uniquement les artifacts qui possèdent tous ces tags.
* `start`: Curseur de pagination pour reprendre une requête précédente, capturé à partir de l'attribut `.cursor` d'un paginateur précédent.
##### Exemples
Dans l'extrait de code ci-après, "type", "entity", "project" et
"artifact\_name" sont des paramètres fictifs représentant respectivement le type d'artifact, l'entité W\&B,
le nom du projet dans lequel l'artifact a été enregistré
et le nom de l'artifact.
```python theme={null}
import wandb
wandb.Api().artifacts(type_name="type", name="entity/project/artifact_name")
```
Mettez l’itération en pause et reprenez-la plus tard à partir de la même position en enregistrant
le `.cursor` du paginateur et en le passant à `start=` :
```python theme={null}
from itertools import islice
import wandb
api = wandb.Api()
# Consommer la première page de résultats, puis sauvegarder le curseur.
page_size = 10
artifacts = api.artifacts(
type_name="type",
name="entity/project/artifact_name",
per_page=page_size,
)
first_page = list(islice(artifacts, page_size))
saved_cursor = artifacts.cursor
# Plus tard (par exemple dans un nouveau processus), reprendre l'itération à partir du curseur sauvegardé.
remaining_artifacts = api.artifacts(
type_name="type",
name="entity/project/artifact_name",
per_page=page_size,
start=saved_cursor,
)
```
### méthode Api.automation()
```python theme={null}
self,
name: 'str', *,
entity: 'str | None' = None
```
Renvoie la seule automatisation correspondant aux paramètres.
##### Arguments
* `name`: Le nom de l’automatisation à récupérer.
* `entity`: L’entité pour laquelle récupérer l’automatisation.
##### Exceptions levées
* `ValueError`: Si aucune ou plusieurs automatisations correspondent aux critères de recherche.
##### Exemples
Récupérer une automatisation existante nommée "my-automation" :
```python theme={null}
import wandb
api = wandb.Api()
automation = api.automation(name="my-automation")
```
Obtenez l’automatisation existante nommée "other-automation" dans l’entité "my-team":
```python theme={null}
automation = api.automation(name="other-automation", entity="my-team")
```
### méthode Api.automations()
```python theme={null}
self,
entity: 'str | None' = None, *,
name: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie un itérateur sur toutes les automatisations correspondant aux paramètres donnés.
Si aucun paramètre n’est fourni, l’itérateur renvoyé contiendra toutes les
automatisations auxquelles l’utilisateur a accès.
##### Arguments
* `entity`: L’entité pour laquelle récupérer les automatisations.
* `name`: Le nom de l’automatisation à récupérer.
* `per_page`: Le nombre d’automatisations à récupérer par page. La valeur par défaut est 50. En général, il n’y a aucune raison de modifier ce paramètre.
* `start`: Curseur de pagination permettant de reprendre une requête précédente, capturé à partir de l’attribut `.cursor` d’un paginateur précédent.
##### Exemples
Récupérez toutes les automatisations existantes pour l’entité "my-team" :
```python theme={null}
import wandb
api = wandb.Api()
automations = api.automations(entity="my-team")
```
### méthode Api.create\_automation()
```python theme={null}
self,
obj: 'NewAutomation', *,
fetch_existing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'
```
Créer une nouvelle automatisation.
##### Arguments
* `obj`: L'automatisation à créer.
* `fetch_existing`: Si True et qu'une automatisation en conflit existe déjà, tentez de récupérer l'automatisation existante au lieu de lever une erreur.
* `kwargs`:
##### Exemples
Créer une nouvelle automatisation nommée "my-automation" qui envoie une notification Slack
lorsqu'un run d'un projet spécifique journalise une métrique dépassant un seuil personnalisé :
```python theme={null}
import wandb
from wandb.automations import OnRunMetric, RunEvent, SendNotification
api = wandb.Api()
project = api.project("my-project", entity="my-team")
# Utiliser la première intégration Slack pour l'équipe
slack_hook = next(api.slack_integrations(entity="my-team"))
event = OnRunMetric(
scope=project,
filter=RunEvent.metric("custom-metric") > 10,
)
action = SendNotification.from_integration(slack_hook)
automation = api.create_automation(
event >> action,
name="my-automation",
description="Send a Slack message whenever 'custom-metric' exceeds 10.",
)
```
### méthode Api.create\_custom\_chart()
```python theme={null}
self,
entity: 'str',
name: 'str',
display_name: 'str',
spec_type: "Literal['vega2']",
access: "Literal['private', 'public']",
spec: 'str | dict'
```
Créez un préréglage de graphique personnalisé et renvoyez son ID.
##### Arguments
* `entity`: L’entité (utilisateur ou équipe) à laquelle appartient le graphique
* `name`: Identifiant unique du préréglage de graphique
* `display_name`: Nom lisible affiché dans l’interface utilisateur
* `spec_type`: Type de spécification. Doit être "vega2" pour les spécifications Vega-Lite v2.
* `access`: Niveau d’accès au graphique :
* "private": Le graphique est accessible uniquement à l’entité qui l’a créé
* "public": Le graphique est accessible publiquement
* `spec`: La spécification Vega/Vega-Lite sous forme de dictionnaire ou de chaîne JSON
##### Exceptions levées
* `wandb.Error`: Si la création du graphique échoue
* `UnsupportedError`: Si le serveur ne prend pas en charge les graphiques personnalisés
##### Exemples
```python theme={null}
import wandb
api = wandb.Api()
# Définir une spécification simple de graphique à barres
vega_spec = {
"$schema": "https://vega.github.io/schema/vega-lite/v6.json",
"mark": "bar",
"data": {"name": "wandb"},
"encoding": {
"x": {"field": "${field:x}", "type": "ordinal"},
"y": {"field": "${field:y}", "type": "quantitative"},
},
}
# Créer le graphique personnalisé
chart_id = api.create_custom_chart(
entity="my-team",
name="my-bar-chart",
display_name="My Custom Bar Chart",
spec_type="vega2",
access="private",
spec=vega_spec,
)
# Utiliser avec wandb.plot_table()
chart = wandb.plot_table(
vega_spec_name=chart_id,
data_table=my_table,
fields={"x": "category", "y": "value"},
)
```
### méthode Api.create\_project()
```python theme={null}
self,
name: 'str',
entity: 'str'
```
Créer un nouveau projet.
##### Arguments
* `name`: Le nom du nouveau projet.
* `entity`: L’entité du nouveau projet.
### méthode Api.create\_registry()
```python theme={null}
self,
name: 'str',
visibility: "Literal['organization', 'restricted']",
organization: 'str | None' = None,
description: 'str | None' = None,
artifact_types: 'list[str] | None' = None
```
Créer un nouveau registre.
##### Arguments
* `name`: Le nom du registre. Le nom doit être unique au sein de l’organisation.
* `visibility`: La visibilité du registre. organization: Toute personne appartenant à l’organisation peut consulter ce registre. Vous pourrez modifier les rôles ultérieurement depuis les paramètres de l’interface utilisateur. restricted: Seuls les membres invités via l’interface utilisateur peuvent accéder à ce registre. Le partage public est désactivé.
* `organization`: L’organisation du registre. Si aucune organisation n’est définie dans les paramètres, l’organisation sera récupérée depuis l’entité si celle-ci n’appartient qu’à une seule organisation.
* `description`: La description du registre.
* `artifact_types`: Les types d’artifact acceptés par le registre. Un type ne doit pas dépasser 128 caractères ni inclure les caractères `/` ou `:`. Si ce paramètre n’est pas spécifié, tous les types sont acceptés. Les types autorisés ajoutés au registre ne peuvent pas être supprimés par la suite.
##### Exemples
```python theme={null}
import wandb
api = wandb.Api()
registry = api.create_registry(
name="my-registry",
visibility="restricted",
organization="my-org",
description="This is a test registry",
artifact_types=["model"],
)
```
### méthode Api.create\_run()
```python theme={null}
self, *,
run_id: 'str | None' = None,
project: 'str | None' = None,
entity: 'str | None' = None
```
Créer un nouveau run.
##### Arguments
* `run_id`: L’ID à attribuer au run. S’il n’est pas spécifié, W\&B génère un ID aléatoire.
* `project`: Le projet dans lequel enregistrer le run. Si aucun projet n’est spécifié, le run est enregistré dans un projet appelé "Uncategorized".
* `entity`: L’entité propriétaire du projet. Si aucune entité n’est spécifiée, le run est enregistré dans l’entité par défaut.
### méthode Api.create\_run\_queue()
```python theme={null}
self,
name: 'str',
type: 'public.RunQueueResourceType',
entity: 'str | None' = None,
prioritization_mode: 'public.RunQueuePrioritizationMode | None' = None,
config: 'dict | None' = None,
template_variables: 'dict | None' = None
```
Créer une nouvelle file d'attente de run dans W\&B Launch.
##### Arguments
* `name`: nom de la file d'attente à créer
* `type`: type de ressource à utiliser pour la file d'attente. L'une des valeurs suivantes : "local-container", "local-process", "kubernetes","sagemaker", ou "gcp-vertex".
* `entity`: nom de l'entité dans laquelle créer la file d'attente. Si `None`, utiliser l'entité configurée ou l'entité par défaut.
* `prioritization_mode`: version du mode de priorisation à utiliser. Soit "V0", soit `None`.
* `config`: configuration de ressource par défaut à utiliser pour la file d'attente. Utiliser Handlebars (par ex. `{{var}}`) pour spécifier des variables de modèle.
* `template_variables`: dictionnaire des schémas des variables de modèle à utiliser avec la configuration.
### méthode Api.create\_team()
```python theme={null}
self,
team: 'str',
admin_username: 'str | None' = None
```
Créer une nouvelle équipe.
Pour les utilisateurs de W\&B Cloud mutualisé, définissez l’organisation API par défaut dans
vos Paramètres utilisateur de l’interface utilisateur W\&B avant d’appeler `create_team()`.
Ce paramètre détermine l’organisation à laquelle la nouvelle équipe appartiendra.
##### Arguments
* `team`: Le nom de l’équipe.
* `admin_username`: Le nom d’utilisateur de l’administrateur de l’équipe. Par défaut, il s’agit de l’utilisateur actuel.
### méthode Api.create\_user()
```python theme={null}
self,
email: 'str',
admin: 'bool | None' = False
```
Créer un nouvel utilisateur.
##### Arguments
* `email`: L’adresse e-mail de l’utilisateur.
* `admin`: Définit l’utilisateur comme administrateur global de l’instance.
### méthode Api.delete\_automation()
```python theme={null}
self,
obj: 'Automation | str'
```
Supprime une automatisation.
##### Arguments
* `obj` : l’automatisation à supprimer, ou son ID.
### méthode Api.flush()
```python theme={null}
(self)
```
Videz le cache local.
L'objet api conserve un cache local des runs. Si l'état du run
est susceptible de changer pendant l'exécution de votre script, vous devez donc effacer le cache local
avec `api.flush()` pour obtenir les dernières valeurs associées au run.
### méthode Api.from\_path()
```python theme={null}
(self,
path: 'str')
```
Renvoie un run, un balayage, un projet ou un rapport à partir d’un chemin.
##### Arguments
* `path`: Le chemin vers le projet, le run, le balayage ou le rapport
##### Exemples
Dans les extraits de code qui suivent, "project", "team", "run\_id", "sweep\_id",
et "report\_name" sont des espaces réservés désignant respectivement le projet, la équipe, le run ID,
le sweep ID et le nom d’un rapport spécifique.
```python theme={null}
import wandb
api = wandb.Api()
project = api.from_path("project")
team_project = api.from_path("team/project")
run = api.from_path("team/project/runs/run_id")
sweep = api.from_path("team/project/sweeps/sweep_id")
report = api.from_path("team/project/reports/report_name")
```
### méthode Api.integrations()
```python theme={null}
self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie un itérateur sur toutes les intégrations d’une entité.
##### Arguments
* `entity`: L’entité (par ex. le nom d’équipe) pour laquelle récupérer les intégrations. Si elle n’est pas fournie, l’entité par défaut de l’utilisateur sera utilisée.
* `per_page`: Nombre d’intégrations à récupérer par page. La valeur par défaut est 50. En général, il n’y a aucune raison de la modifier.
* `start`:
### méthode Api.job()
```python theme={null}
self,
name: 'str | None',
path: 'str | None' = None
```
Renvoie un objet `Job`.
##### Arguments
* `name` : Le nom du job.
* `path` : Le chemin racine à partir duquel télécharger l'artifact du job.
### méthode Api.list\_jobs()
```python theme={null}
self,
entity: 'str',
project: 'str'
```
Renvoie une liste de jobs, s'il y en a, pour l'entité et le projet indiqués.
##### Arguments
* `entity`: L'entité associée aux jobs listés.
* `project`: Le projet associé aux jobs listés.
### méthode Api.organization()
```python theme={null}
self,
name: 'str | None' = None
```
Renvoyer l’`Organisation` correspondante.
##### Arguments
* `name` : Nom de l’organisation. Si ce paramètre est omis, cette méthode tente de déterminer et de renvoyer l’organisation par défaut courante.
### méthode Api.project()
```python theme={null}
self,
name: 'str',
entity: 'str | None' = None
```
Renvoie le `projet` portant le nom indiqué (et l'entité, si elle est renseignée).
##### Arguments
* `name`: Le nom du projet.
* `entity`: Nom de l'entité demandée. Si la valeur est `None`, l'entité par défaut transmise à `Api` sera utilisée. S'il n'existe pas d'entité par défaut, une `ValueError` sera levée.
### méthode Api.projects()
```python theme={null}
self,
entity: 'str | None' = None,
per_page: 'int' = 200
```
Récupère les projets pour une entité donnée.
##### Arguments
* `entity`: Nom de l’entité demandée. Si `None`, utilise l’entité par défaut transmise à `Api`. S’il n’y a pas d’entité par défaut, lève une `ValueError`.
* `per_page`: Définit la taille de page pour la pagination des requêtes. En général, il n’est pas nécessaire de la modifier.
### méthode Api.queued\_run()
```python theme={null}
(self,
entity: 'str',
project: 'str',
queue_name: 'str',
run_queue_item_id: 'str', project_queue=None, priority=None)
```
Retourne un seul run en file d'attente à partir du chemin.
Analyse les chemins au format `entity/project/queue_id/run_queue_item_id`.
##### Arguments
* `entity`:
* `project`:
* `queue_name`:
* `run_queue_item_id`:
* `project_queue`:
* `priority`:
### méthode Api.registries()
```python theme={null}
self,
organization: 'str | None' = None,
filter: 'dict[str, Any] | None' = None,
order: 'str | None' = None,
per_page: 'int' = 100,
start: 'str | None' = None
```
Renvoie un itérateur différé d’objets `Registry`.
Utilisez cet itérateur pour rechercher et filtrer des registres, des collections,
ou des versions d’artifact dans le registre de votre organisation.
##### Arguments
* `organization`: Organisation du registre à récupérer. Si elle n’est pas spécifiée, utilisez l’organisation indiquée dans les paramètres de l’utilisateur.
* `filter`: Filtre de type MongoDB à appliquer à chaque objet de l’itérateur différé du registre. Les champs disponibles pour filtrer les registres sont `name`, `description`, `created_at`, `updated_at`. Les champs disponibles pour filtrer les collections sont `name`, `tag`, `description`, `created_at`, `updated_at` Les champs disponibles pour filtrer les versions sont `tag`, `alias`, `created_at`, `updated_at`, `metadata`
* `order`: Chaîne facultative permettant de spécifier l’ordre des résultats. Si elle est préfixée par '+', le tri est croissant (par défaut). Si elle est préfixée par '-', le tri est décroissant.
* `per_page`: Définit la taille de page pour la pagination des requêtes.
* `start`: Curseur de pagination pour reprendre une requête précédente, capturé à partir de l’attribut `.cursor` d’un paginateur précédent.
##### Exemples
Trouver tous les registres dont le nom contient "model"
```python theme={null}
import wandb
api = wandb.Api() # spécifiez une organisation si votre entité appartient à plusieurs organisations
api.registries(filter={"name": {"$regex": "model"}})
```
Recherchez toutes les collections dans les registres portant le nom "my\_collection" et le tag "my\_tag"
```python theme={null}
api.registries().collections(filter={"name": "my_collection", "tag": "my_tag"})
```
Rechercher toutes les versions d’artifact dans les registres dont le nom de collection contient "my\_collection" et dont une version porte l’alias "best"
```python theme={null}
api.registries().collections(
filter={"name": {"$regex": "my_collection"}}
).versions(filter={"alias": "best"})
```
Trouvez toutes les versions d'artifact dans les registres qui contiennent "model" et qui portent le tag "prod" ou l'alias "best"
```python theme={null}
api.registries(filter={"name": {"$regex": "model"}}).versions(
filter={"$or": [{"tag": "prod"}, {"alias": "best"}]}
)
```
Mettez l’itération en pause et reprenez-la plus tard à la même position en enregistrant
le `.cursor` du paginateur et en le passant à `start=` :
```python theme={null}
from itertools import islice
import wandb
api = wandb.Api()
# Consommer la première page de résultats, puis sauvegarder le curseur.
page_size = 10
registries = api.registries(per_page=page_size)
first_page = list(islice(registries, page_size))
saved_cursor = registries.cursor
# Plus tard (par exemple dans un nouveau processus), reprendre l'itération à partir du curseur sauvegardé.
remaining_registries = api.registries(per_page=page_size, start=saved_cursor)
```
### méthode Api.registry()
```python theme={null}
self,
name: 'str',
organization: 'str | None' = None
```
Renvoie un registre à partir de son nom.
##### Arguments
* `name` : Le nom du registre. Il ne comprend pas le préfixe `wandb-registry-`.
* `organization` : L’organisation du registre. Si aucune organisation n’est définie dans la configuration, l’organisation sera récupérée à partir de l’entité si celle-ci n’appartient qu’à une seule organisation.
##### Exemples
Récupérer et mettre à jour un registre
```python theme={null}
import wandb
api = wandb.Api()
registry = api.registry(name="my-registry", organization="my-org")
registry.description = "This is an updated description"
registry.save()
```
### méthode Api.reports()
```python theme={null}
self,
path: 'str' = '',
name: 'str | None' = None,
per_page: 'int' = 50
```
Obtenir les rapports pour un chemin de projet donné.
Remarque : l'API `wandb.Api.reports()` est en version bêta et changera probablement dans de prochaines versions.
##### Arguments
* `path`: Chemin vers le projet dans lequel se trouve le rapport. Indiquez en préfixe l'entité qui a créé le projet, suivie d'une barre oblique.
* `name`: Nom du rapport demandé.
* `per_page`: Définit la taille de page pour la pagination des requêtes. Il n'y a généralement aucune raison de modifier cette valeur.
##### Exemples
```python theme={null}
import wandb
wandb.Api.reports("entity/project")
```
### méthode Api.run()
```python theme={null}
(self, path='')
```
Renvoie un run unique en interprétant le chemin au format `entity/project/run_id`.
##### Arguments
* `path` : chemin du run au format `entity/project/run_id`. Si `api.entity` est défini, il peut être au format `project/run_id`, et si `api.project` est défini, il peut simplement s’agir du `run_id`.
##### Exceptions levées
* `RunNotFoundError` : Si une run est introuvable ou si ses données ne peuvent pas être chargées.
### méthode Api.run\_queue()
```python theme={null}
(self,
entity: 'str',
name: 'str')
```
Renvoie la `RunQueue` nommée associée à l’entité.
Voir `Api.create_run_queue` pour plus d’informations sur la façon de créer une file d’attente de run.
##### Arguments
* `entity`:
* `name`:
### méthode Api.runs()
```python theme={null}
(self,
path: 'str | None' = None,
filters: 'dict[str, Any] | None' = None,
order: 'str' = '+created_at',
per_page: 'int' = 50,
include_sweeps: 'bool' = False,
lazy: 'bool' = True)
```
Renvoie un objet `Runs`, qui itère de façon différée sur les objets `Run`.
Les champs sur lesquels vous pouvez filtrer incluent :
* `createdAt` : l’horodatage de création du run. (au format ISO 8601, par ex. "2023-01-01T12:00:00Z")
* `displayName` : le nom d’affichage lisible du run. (par ex. "eager-fox-1")
* `duration` : la durée totale d’exécution du run en secondes.
* `group` : le nom du groupe utilisé pour organiser des runs associés.
* `host` : le nom d’hôte sur lequel le run a été exécuté.
* `jobType` : le type de job ou le rôle du run.
* `name` : l’identifiant unique du run. (par ex. "a1b2cdef")
* `state` : l’état actuel du run.
* `tags` : les tags associés au run.
* `username` : le nom d’utilisateur de l’utilisateur ayant lancé le run
En outre, vous pouvez filtrer sur des éléments de la configuration du run ou des métriques de résumé, par exemple `config.experiment_name`, `summary_metrics.loss`, etc.
Pour des filtres plus complexes, vous pouvez utiliser les opérateurs de requête MongoDB. Pour plus de détails, voir : [https://docs.mongodb.com/manual/reference/operator/query](https://docs.mongodb.com/manual/reference/operator/query) Les opérations suivantes sont prises en charge :
* `$and`
* `$or`
* `$nor`
* `$eq`
* `$ne`
* `$gt`
* `$gte`
* `$lt`
* `$lte`
* `$in`
* `$nin`
* `$exists`
* `$regex`
##### Arguments
* `path` : (str) chemin vers le projet, doit être de la forme : "entity/project"
* `filters` : (dict) requêtes pour des runs spécifiques à l’aide du langage de requête MongoDB. Vous pouvez filtrer sur des propriétés du run telles que config.key, summary\_metrics.key, state, entity, createdAt, etc. Par exemple : `{"config.experiment_name": "foo"}` trouverait les runs dont l’entrée de configuration pour le nom de l’expérience est définie sur "foo"
* `order` : (str) L’ordre peut être `created_at`, `heartbeat_at`, `config.*.value` ou `summary_metrics.*`. Si vous faites précéder l’ordre d’un +, le tri est croissant (par défaut). Si vous faites précéder l’ordre d’un -, le tri est décroissant. L’ordre par défaut est run.created\_at, du plus ancien au plus récent.
* `per_page` : (int) Définit la taille de page pour la pagination des requêtes.
* `include_sweeps` : (bool) Indique s’il faut récupérer de manière anticipée l’objet balayage dans chaque résultat de run.
* `lazy` : (bool) Indique s’il faut utiliser le chargement différé pour de meilleures performances. Quand True (par défaut), seules les métadonnées essentielles du run sont chargées initialement. Les champs volumineux comme config, summaryMetrics et systemMetrics sont chargés à la demande lors de l’accès. Définissez cette option sur False pour charger toutes les données d’emblée.
##### Exemples
```python theme={null}
import wandb
from wandb.apis.public import Api
# Trouver les runs dans le projet où config.experiment_name a été défini sur "foo"
Api.runs(path="my_entity/project", filters={"config.experiment_name": "foo"})
```
```python theme={null}
# Trouver les runs dans le projet où config.experiment_name a été défini sur "foo" ou "bar"
Api.runs(
path="my_entity/project",
filters={
"$or": [
{"config.experiment_name": "foo"},
{"config.experiment_name": "bar"},
]
},
)
```
```python theme={null}
# Trouver les runs dans le projet où config.experiment_name correspond à une expression régulière
Api.runs(
path="my_entity/project",
filters={"config.experiment_name": {"$regex": "b.*"}},
)
```
Remarque :
Les expressions régulières utilisent la synt[https://github.com/google/re2/wiki/Syntax](https://github.com/google/re2/wiki/Syntax)axe RE2 de Google
```python theme={null}
# Trouver les runs dans le projet dont le nom correspond à une expression régulière
Api.runs(
path="my_entity/project", filters={"display_name": {"$regex": "^foo.*"}}
)
```
```python theme={null}
# Trouver les runs du projet triés par perte croissante
Api.runs(path="my_entity/project", order="+summary_metrics.loss")
```
### méthode Api.slack\_integrations()
```python theme={null}
self, *,
entity: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie un itérateur d’intégrations Slack pour une entité.
##### Arguments
* `entity`: L’entité (par ex. le nom d’équipe) pour laquelle récupérer les intégrations. Si elle n’est pas fournie, l’entité par défaut de l’utilisateur sera utilisée.
* `per_page`: Nombre d’intégrations à récupérer par page. La valeur par défaut est 50. En général, il n’y a aucune raison de la modifier.
* `start`:
##### Exemples
Obtenez toutes les intégrations Slack enregistrées pour l’équipe "my-team" :
```python theme={null}
import wandb
api = wandb.Api()
slack_integrations = api.slack_integrations(entity="my-team")
```
Trouvez uniquement les intégrations Slack qui publient dans des canaux dont le nom commence par "team-alerts-" :
```python theme={null}
slack_integrations = api.slack_integrations(entity="my-team")
team_alert_integrations = [
ig
for ig in slack_integrations
if ig.channel_name.startswith("team-alerts-")
]
```
### méthode Api.sweep()
```python theme={null}
(self, path='')
```
Renvoie un balayage en analysant un chemin au format `entity/project/sweep_id`.
##### Arguments
* `path` : Chemin vers le balayage au format entity/project/sweep\_id. Si `api.entity` est défini, ce chemin peut être au format project/sweep\_id et, si `api.project` est défini, il peut simplement s’agir de sweep\_id.
### méthode Api.sync\_tensorboard()
```python theme={null}
(self, root_dir, run_id=None, project=None, entity=None)
```
Synchroniser un répertoire local contenant des fichiers tfevent avec wandb.
##### Arguments
* `root_dir`:
* `run_id`:
* `project`:
* `entity`:
### méthode Api.team()
```python theme={null}
self,
team: 'str'
```
Renvoie le `Team` correspondant au nom fourni.
##### Arguments
* `team` : le nom de l’équipe.
### méthode Api.update\_automation()
```python theme={null}
self,
obj: 'Automation', *,
create_missing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'
```
Mettez à jour une automatisation existante.
##### Arguments
* `obj`: L’automatisation à mettre à jour. Il doit s’agir d’une automatisation existante.
* `create_missing`: Si True et que l’automatisation n’existe pas, créez-la.
* `kwargs`:
##### Exemples
Désactivez et modifiez la description d’une automatisation existante ("my-automation") :
```python theme={null}
import wandb
api = wandb.Api()
automation = api.automation(name="my-automation")
automation.enabled = False
automation.description = "Kept for reference, but no longer used."
updated_automation = api.update_automation(automation)
```
OU
```python theme={null}
import wandb
api = wandb.Api()
automation = api.automation(name="my-automation")
updated_automation = api.update_automation(
automation,
enabled=False,
description="Kept for reference, but no longer used.",
)
```
### méthode Api.upsert\_run\_queue()
```python theme={null}
(self,
name: 'str',
resource_config: 'dict',
resource_type: 'public.RunQueueResourceType',
entity: 'str | None' = None,
template_variables: 'dict | None' = None,
external_links: 'dict | None' = None,
prioritization_mode: 'public.RunQueuePrioritizationMode | None' = None)
```
Crée ou met à jour une file d'attente de run dans W\&B Launch.
##### Arguments
* `name`: Nom de la file d'attente à créer
* `resource_config`: Configuration de ressources par défaut, facultative, à utiliser pour la file d'attente. Utilisez des expressions Handlebars (par ex. `{{var}}`) pour spécifier des variables de modèle.
* `resource_type`: Type de ressource à utiliser pour la file d'attente. L'une des valeurs suivantes : "local-container", "local-process", "kubernetes", "sagemaker" ou "gcp-vertex".
* `entity`: Nom facultatif de l'entité pour laquelle créer la file d'attente. Si `None`, utilisez l'entité configurée ou l'entité par défaut.
* `template_variables`: Dictionnaire des schémas de variables de modèle à utiliser avec la configuration.
* `external_links`: Dictionnaire facultatif de liens externes à utiliser avec la file d'attente.
* `prioritization_mode`: Version facultative de la priorisation à utiliser. Soit "V0", soit `None`
### méthode Api.user()
```python theme={null}
self,
username_or_email: 'str'
```
Renvoie un utilisateur à partir d’un nom d’utilisateur ou d’une adresse e-mail.
Cette fonction ne fonctionne que pour les administrateurs locaux. Utilisez `api.viewer`
pour récupérer votre propre objet utilisateur.
##### Arguments
* `username_or_email`: Le nom d’utilisateur ou l’adresse e-mail de l’utilisateur.
### méthode Api.users()
```python theme={null}
self,
username_or_email: 'str'
```
Renvoie tous les utilisateurs à partir d’une requête partielle sur un nom d’utilisateur ou une adresse e-mail.
Cette fonction fonctionne uniquement pour les administrateurs locaux. Utilisez `api.viewer`
pour obtenir votre propre objet utilisateur.
##### Arguments
* `username_or_email`: Le préfixe ou le suffixe de l’utilisateur que vous souhaitez trouver.
### méthode Api.webhook\_integrations()
```python theme={null}
self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie un itérateur d’intégrations webhook pour une entité.
##### Arguments
* `entity`: L’entité (par ex. le nom d’équipe) pour laquelle récupérer les intégrations. Si elle n’est pas fournie, l’entité par défaut de l’utilisateur sera utilisée.
* `per_page`: Nombre d’intégrations à récupérer par page. La valeur par défaut est 50. En général, il n’y a aucune raison de la modifier.
* `start`:
##### Exemples
Obtenez toutes les intégrations webhook enregistrées pour l’équipe "my-team" :
```python theme={null}
import wandb
api = wandb.Api()
webhook_integrations = api.webhook_integrations(entity="my-team")
```
Recherchez uniquement les intégrations webhook qui envoient des requêtes à "[https://my-fake-url.com](https://my-fake-url.com)":
```python theme={null}
webhook_integrations = api.webhook_integrations(entity="my-team")
my_webhooks = [
ig
for ig in webhook_integrations
if ig.url_endpoint.startswith("https://my-fake-url.com")
]
```