> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Api
export const GitHubLink = ({url}) =>
Source GitHub
;
## class `Api`
Permet d’interroger le serveur W\&B.
**Exemples :**
```python theme={null}
import wandb
wandb.Api()
```
### méthode `Api.__init__`
```python theme={null}
__init__(
overrides: 'dict[str, Any] | None' = None,
timeout: 'int | None' = None,
api_key: 'str | None' = None
) → None
```
Initialisez l’API.
**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.
***
### propriété Api.default\_entity
Renvoie l’entité W\&B par défaut.
**Retourne :**
* `str | None`: La valeur de la propriété default\_entity.
***
### propriété Api.user\_agent
Renvoie l’agent utilisateur public de W\&B.
**Retourne :**
* `str`: La valeur de la propriété user\_agent.
***
### propriété Api.viewer
Renvoie l’objet viewer.
**Exceptions levées :**
* `ValueError` : Si les données du viewer ne peuvent pas être récupérées depuis W\&B.
* `WandbApiFailedError` : Si une erreur survient lors de la requête GraphQL.
**Retourne :**
* `User` : La valeur de la propriété viewer.
***
### méthode `Api.artifact`
```python theme={null}
artifact(name: 'str', type: 'str | None' = None)
```
Renvoie un artifact unique.
**Arguments :**
* `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.
**Retourne :**
Un objet `Artifact`.
**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")
```
**Remarque :**
> Cette méthode est destinée uniquement à un usage externe. N’appelez pas `api.artifact()` dans le code du dépôt wandb.
***
### méthode `Api.artifact_collection`
```python theme={null}
artifact_collection(type_name: 'str', name: 'str') → ArtifactCollection
```
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.
**Retourne :**
Un objet `ArtifactCollection`.
**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}
artifact_collection_exists(name: 'str', type: 'str') → bool
```
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.
**Retourne :**
True si la collection d'artifacts existe, False sinon.
**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}
artifact_collections(
project_name: 'str',
type_name: 'str',
order: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
) → ArtifactCollections
```
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.
**Retourne :**
Un objet itérable `ArtifactCollections`.
***
### méthode `Api.artifact_exists`
```python theme={null}
artifact_exists(name: 'str', type: 'str | None' = None) → bool
```
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.
**Retourne :**
True si la version de l'artifact existe, False sinon.
**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}
artifact_type(type_name: 'str', project: 'str | None' = None) → ArtifactType
```
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.
**Retourne :**
Un objet `ArtifactType`.
***
### méthode `Api.artifact_types`
```python theme={null}
artifact_types(
project: 'str | None' = None,
start: 'str | None' = None
) → ArtifactTypes
```
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.
**Retourne :**
Un objet `ArtifactTypes` itérable.
***
### méthode `Api.artifact_versions`
```python theme={null}
artifact_versions(type_name, name, per_page=50)
```
Obsolète. Utilisez la méthode `Api.artifacts(type_name, name)` à la place.
***
### méthode `Api.artifacts`
```python theme={null}
artifacts(
type_name: 'str',
name: 'str',
order: 'str | None' = None,
per_page: 'int' = 50,
tags: 'list[str] | None' = None,
start: 'str | None' = None
) → Artifacts
```
Renvoie une collection `Artifacts`.
**Arguments :**
* `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.
**Retourne :**
Un objet `Artifacts` itérable.
**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}
automation(name: 'str', entity: 'str | None' = None) → Automation
```
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}
automations(
entity: 'str | None' = None,
name: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
) → Iterator[Automation]
```
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.
**Retourne :**
Une liste d’automatisations.
**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}
create_automation(
obj: 'NewAutomation',
fetch_existing: 'bool' = False,
**kwargs: 'Unpack[WriteAutomationsKwargs]'
) → Automation
```
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: Toute valeur supplémentaire à attribuer à l'automatisation avant sa création. Si elles sont fournies, elles remplaceront toute valeur déjà définie sur l'automatisation :
* `name`: Le nom de l'automatisation.
* `description`: La description de l'automatisation.
* `enabled`: Indique si l'automatisation est activée.
* `scope`: La portée de l'automatisation.
* `event`: L'événement qui déclenche l'automatisation.
* `action`: L'action déclenchée par l'automatisation.
**Retourne :**
L'automatisation enregistrée.
**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}
create_custom_chart(
entity: 'str',
name: 'str',
display_name: 'str',
spec_type: "Literal['vega2']",
access: "Literal['private', 'public']",
spec: 'str | dict'
) → str
```
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
**Retourne :**
L’ID du préréglage de graphique créé au format "entity/name"
**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
**Exemple :**
```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}
create_project(name: 'str', entity: 'str') → None
```
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}
create_registry(
name: 'str',
visibility: "Literal['organization', 'restricted']",
organization: 'str | None' = None,
description: 'str | None' = None,
artifact_types: 'list[str] | None' = None
) → Registry
```
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.
**Retourne :**
Un objet registre.
**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}
create_run(
run_id: 'str | None' = None,
project: 'str | None' = None,
entity: 'str | None' = None
) → public.Run
```
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.
**Retourne :**
Le `Run` nouvellement créé.
***
### méthode `Api.create_run_queue`
```python theme={null}
create_run_queue(
name: 'str',
type: 'public.RunQueueResourceType',
entity: 'str | None' = None,
prioritization_mode: 'public.RunQueuePrioritizationMode | None' = None,
config: 'dict | None' = None,
template_variables: 'dict | None' = None
) → public.RunQueue
```
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.
**Retourne :**
Le `RunQueue` nouvellement créé.
**Exceptions levées :**
`ValueError` si l'un des paramètres n'est pas valide, `wandb.Error` en cas d'erreurs d'API wandb
***
### méthode `Api.create_team`
```python theme={null}
create_team(team: 'str', admin_username: 'str | None' = None) → Team
```
Créer une nouvelle équipe.
**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.
**Retourne :**
Un objet `Team`.
***
### méthode `Api.create_user`
```python theme={null}
create_user(email: 'str', admin: 'bool | None' = False) → User
```
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.
**Retourne :**
Un objet `User`.
***
### méthode `Api.delete_automation`
```python theme={null}
delete_automation(obj: 'Automation | str') → Literal[True]
```
Supprime une automatisation.
**Arguments :**
* `obj` : l’automatisation à supprimer, ou son ID.
**Retourne :**
True si l’automatisation a été supprimée avec succès.
***
### méthode `Api.flush`
```python theme={null}
flush()
```
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}
from_path(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
**Retourne :**
Une instance de `Project`, `Run`, `Sweep` ou `BetaReport`.
**Exceptions levées :**
`wandb.Error` si le chemin n’est pas valide ou si l’objet n’existe pas.
**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}
integrations(
entity: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
) → Iterator[Integration]
```
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.
**générer :**
* `Iterator[SlackIntegration | WebhookIntegration]`: Un itérateur de toutes les intégrations prises en charge.
***
### méthode `Api.job`
```python theme={null}
job(name: 'str | None', path: 'str | None' = None) → public.Job
```
Renvoie un objet `Job`.
**Arguments :**
* `name` : Le nom du job.
* `path` : Le chemin racine à partir duquel télécharger l'artifact du job.
**Retourne :**
Un objet `Job`.
***
### méthode `Api.list_jobs`
```python theme={null}
list_jobs(entity: 'str', project: 'str') → list[dict[str, Any]]
```
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.
**Retourne :**
Une liste de jobs correspondants.
***
### méthode `Api.project`
```python theme={null}
project(name: 'str', entity: 'str | None' = None) → public.Project
```
Renvoie le `Project` 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.
**Retourne :**
Un objet `Project`.
***
### méthode `Api.projects`
```python theme={null}
projects(entity: 'str | None' = None, per_page: 'int' = 200) → public.Projects
```
Récupère les Projects 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.
**Retourne :**
Un objet `Projects`, qui est une collection itérable d’objets `Project`.
***
### méthode `Api.queued_run`
```python theme={null}
queued_run(
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`.
***
### méthode `Api.registries`
```python theme={null}
registries(
organization: 'str | None' = None,
filter: 'dict[str, Any] | None' = None,
order: 'str | None' = None,
per_page: 'int' = 100,
start: 'str | None' = None
) → Registries
```
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.
**Retourne :**
Un itérateur différé d’objets `Registry`.
**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}
registry(name: 'str', organization: 'str | None' = None) → Registry
```
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.
**Retourne :**
Un objet registre.
**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}
reports(
path: 'str' = '',
name: 'str | None' = None,
per_page: 'int' = 50
) → public.Reports
```
Obtenir les Reports 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.
**Retourne :**
Un objet `Reports`, qui est une collection itérable d'objets `BetaReport`.
**Exemples :**
```python theme={null}
import wandb
wandb.Api.reports("entity/project")
```
***
### méthode `Api.run`
```python theme={null}
run(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.
**Retourne :**
Un objet `Run`.
***
### méthode `Api.run_queue`
```python theme={null}
run_queue(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.
***
### méthode `Api.runs`
```python theme={null}
runs(
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.
* `For example` : `{"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.
**Retourne :**
Un objet `Runs`, qui est une collection itérable d’objets `Run`.
**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
# (les ancres ne sont pas prises en charge)
Api.runs(
path="my_entity/project",
filters={"config.experiment_name": {"$regex": "b.*"}},
)
```
```python theme={null}
# Trouver les runs dans le projet dont le nom correspond à une expression régulière
# (les ancres ne sont pas prises en charge)
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}
slack_integrations(
entity: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
) → Iterator[SlackIntegration]
```
Renvoie un itérateur d’intégrations Slack pour une entité.
**Arguments :**
* `entity` : L’entité (par exemple, le nom de l’équipe) pour laquelle récupérer les intégrations. Si elle n’est pas renseignée, 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’est pas nécessaire de la modifier.
**Génère :**
* `Iterator[SlackIntegration]` : Un itérateur d’intégrations Slack.
**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}
sweep(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.
**Retourne :**
Un objet `Sweep`.
***
### méthode `Api.sync_tensorboard`
```python theme={null}
sync_tensorboard(root_dir, run_id=None, project=None, entity=None)
```
Synchroniser un répertoire local contenant des fichiers tfevent avec wandb.
***
### méthode `Api.team`
```python theme={null}
team(team: 'str') → Team
```
Renvoie le `Team` correspondant au nom fourni.
**Arguments :**
* `team` : le nom de l’équipe.
**Retourne :**
Un objet `Team`.
***
### méthode `Api.update_automation`
```python theme={null}
update_automation(
obj: 'Automation',
create_missing: 'bool' = False,
**kwargs: 'Unpack[WriteAutomationsKwargs]'
) → Automation
```
Mettez à jour une automatisation existante.
**Arguments :**
* `obj` : L’automatisation à mettre à jour. Il doit s’agir d’une automatisation existante. create\_missing (bool) : Si True et que l’automatisation n’existe pas, créez-la. \*\*kwargs : Toute valeur supplémentaire à attribuer à l’automatisation avant sa mise à jour. Si elles sont fournies, elles remplaceront toute valeur déjà définie pour l’automatisation :
* `name` : Le nom de l’automatisation.
* `description` : La description de l’automatisation.
* `enabled` : Indique si l’automatisation est activée.
* `scope` : La portée de l’automatisation.
* `event` : L’événement qui déclenche l’automatisation.
* `action` : L’action déclenchée par l’automatisation.
**Retourne :**
L’automatisation mise à jour.
**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}
upsert_run_queue(
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
* `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.
* `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".
* `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`
**Retourne :**
Le `RunQueue` créé ou mis à jour.
**Exceptions levées :**
ValueError si l'un des paramètres n'est pas valide ; wandb.Error en cas d'erreur de l'API wandb
***
### méthode `Api.user`
```python theme={null}
user(username_or_email: 'str') → User | None
```
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.
**Retourne :**
Un objet `User` ou `None` si aucun utilisateur n’est trouvé.
***
### méthode `Api.users`
```python theme={null}
users(username_or_email: 'str') → list[User]
```
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.
**Retourne :**
Un tableau d’objets `User`.
***
### méthode `Api.webhook_integrations`
```python theme={null}
webhook_integrations(
entity: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
) → Iterator[WebhookIntegration]
```
Renvoie un itérateur d’intégrations webhook pour une entité.
**Arguments :**
* `entity` : L’entité (par exemple, le nom de l’é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 modifier cette valeur.
**Génère :**
* `Iterator[WebhookIntegration]` : Un itérateur d’intégrations webhook.
**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")
]
```