> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Api
export const GitHubLink = ({url, compact = false}) =>
{compact ? "View source" : <>
GitHub source
}
;
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`.
Délai d’expiration HTTP des requêtes API, en secondes. S’il n’est pas spécifié, le délai d’expiration par défaut est utilisé.
Clé API à utiliser pour l’authentification. Si aucune clé n’est fournie, la clé API définie dans l’environnement ou la configuration actuels est utilisée. Si aucune clé API n’est fournie ni configurée dans l’environnement, vous êtes invité à en saisir une.
Renvoie l’entity W\&B par défaut.
Renvoie le user agent public de W\&B.
Renvoie l’objet viewer.
Méthodes
méthode Api.artifact()
```python theme={"system"}
(self,
name: 'str',
type: 'str | None' = None)
```
Renvoie un seul artifact.
Arguments
Le nom de l’artifact. Le nom d’un artifact s’apparente à un chemin de fichier composé, au minimum, du nom du projet dans lequel l’artifact a été journalisé, du nom de l’artifact et de sa version ou de son alias. Vous pouvez également ajouter en préfixe l’entity qui a journalisé l’artifact, suivi d’une barre oblique. Si aucun entity n’est spécifié dans le nom, c’est l’entity défini dans les paramètres du run ou de l’API qui est utilisé.
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 à celui 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 qui désignent respectivement votre entity W\&B, le nom
du projet qui contient l’artifact, le nom de l’artifact
et la version de l’artifact.
```python theme={"system"}
import wandb
# Indiquer le projet, le nom de l’artifact et son alias
wandb.Api().artifact(name="project/artifact:alias")
# Indiquer le projet, le nom de l’artifact et une version précise de celui-ci
wandb.Api().artifact(name="project/artifact:version")
# Indiquer l’entity, le projet, le nom de l’artifact et son alias
wandb.Api().artifact(name="entity/project/artifact:alias")
# Indiquer l’entity, le projet, le nom de l’artifact et une version précise de celui-ci
wandb.Api().artifact(name="entity/project/artifact:version")
```
méthode Api.artifact\_collection()
```python theme={"system"}
self,
type_name: 'str',
name: 'str'
```
Renvoie une seule collection d’artifacts, selon son type.
Vous pouvez utiliser l’objet `ArtifactCollection` renvoyé pour récupérer
des informations sur des artifacts précis de cette collection, entre autres.
Arguments
Le type de collection d’artifacts à récupérer.
Nom d’une collection d’artifacts. Vous pouvez le faire précéder de l’entity qui a journalisé l’artifact, suivi d’une barre oblique.
Exemples
Dans l’extrait de code suivant, "type", "entity", "project" et
"artifact\_name" sont des espaces réservés qui désignent respectivement le type de collection, votre entity
W\&B, le nom du projet contenant l’artifact et le nom
de l’artifact.
```python theme={"system"}
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={"system"}
self,
name: 'str',
type: 'str'
```
Indique si une collection d’artifacts existe dans le projet et l’entity spécifiés.
Arguments
Nom d’une collection d’artifacts. Vous pouvez éventuellement ajouter en préfixe l’entity qui a journalisé l’artifact, suivi d’une barre oblique. Si l’entity ou le projet n’est pas spécifié, la collection est déduite des paramètres redéfinis, s’ils existent. Sinon, l’entity est récupéré à partir des paramètres utilisateur et le projet prend par défaut la valeur « uncategorized ».
Type de la collection d’artifacts.
Exemples
Dans l’extrait de code suivant, "type" et "collection\_name" désignent respectivement le type
de la collection d’artifacts et le nom de la collection.
```python theme={"system"}
import wandb
wandb.Api.artifact_collection_exists(type="type", name="collection_name")
```
Le nom du projet à utiliser comme filtre.
Le nom du type d’artifact à utiliser comme filtre.
Chaîne facultative indiquant l’ordre de tri des résultats. Avec le préfixe '+', le tri est croissant (par défaut). Avec le préfixe '-', le tri est décroissant.
Définit la taille de page pour la pagination de la requête. En général, il n’y a aucune raison de modifier cette valeur.
Curseur de pagination permettant de reprendre une requête antérieure, récupéré depuis l’attribut `.cursor` d’un paginateur précédent.
méthode Api.artifact\_exists()
```python theme={"system"}
self,
name: 'str',
type: 'str | None' = None
```
Indique si une version d’artifact existe dans le projet et l’entity spécifiés.
Arguments
Le nom de l’artifact. Préfixez-le avec l’entity et le projet de l’artifact. Ajoutez à la fin la version ou l’alias de l’artifact, précédé de deux-points. Si l’entity ou le projet n’est pas spécifié, W\&B utilise les paramètres redéfinis s’ils sont renseignés. Sinon, l’entity est récupéré depuis les paramètres utilisateur et le projet est défini sur « Uncategorized ».
Le type de l’artifact.
Exemples
Dans les extraits de code suivants, "entity", "project", "artifact",
"version" et "alias" sont des espaces réservés représentant respectivement votre entity W\&B, le nom
du projet qui contient l’artifact, le nom de l’artifact et
la version de l’artifact.
```python theme={"system"}
import wandb
wandb.Api().artifact_exists("entity/project/artifact:version")
wandb.Api().artifact_exists("entity/project/artifact:alias")
```
Nom ou chemin du projet à utiliser comme filtre.
Curseur de pagination permettant de reprendre une requête antérieure, capturé à partir de l’attribut `.cursor` d’un paginateur précédent.
Le type d’artifacts à récupérer.
Le nom de la collection de l’artifact. Vous pouvez éventuellement le préfixer de l’entity qui a journalisé l’artifact, suivie d’une barre oblique.
Chaîne facultative indiquant l’ordre de tri des résultats. Avec le préfixe '+', le tri est croissant (par défaut). Avec le préfixe '-', le tri est décroissant.
Définit la taille de page pour la pagination de la requête. En règle générale, il n’y a aucune raison de modifier cette valeur.
Renvoie uniquement les artifacts qui possèdent tous ces tags.
Curseur de pagination permettant de reprendre une requête antérieure, récupéré depuis l’attribut `.cursor` d’un paginateur précédent.
Exemples
Dans l’extrait de code suivant, "type", "entity", "project" et
"artifact\_name" sont des espaces réservés qui désignent respectivement le type d’artifact, l’entity W\&B,
le nom du projet dans lequel l’artifact a été journalisé
et le nom de l’artifact.
```python theme={"system"}
import wandb
wandb.Api().artifacts(type_name="type", name="entity/project/artifact_name")
```
Pour interrompre l’itération et la reprendre plus tard au même endroit, enregistrez
le `.cursor` du paginateur, puis transmettez-le via `start=` :
```python theme={"system"}
from itertools import islice
import wandb
api = wandb.Api()
# Parcourir la première page de résultats, puis enregistrer 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 enregistré.
remaining_artifacts = api.artifacts(
type_name="type",
name="entity/project/artifact_name",
per_page=page_size,
start=saved_cursor,
)
```
Le nom de l’automatisation à récupérer.
L’entity dont récupérer l’automatisation.
Exceptions levées
* `ValueError` : si aucune automatisation ne correspond aux critères de recherche, ou si plusieurs y correspondent.
Exemples
Obtenir une automatisation existante nommée "my-automation" :
```python theme={"system"}
import wandb
api = wandb.Api()
automation = api.automation(name="my-automation")
```
Obtenir une automatisation existante nommée "other-automation" dans l’entity "my-team" :
```python theme={"system"}
automation = api.automation(name="other-automation", entity="my-team")
```
méthode Api.automations()
```python theme={"system"}
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 indiqués.
Si aucun paramètre n’est fourni, l’itérateur renvoyé contiendra toutes les
Automatisations auxquelles l’utilisateur a accès.
Arguments
L’entity dont vous souhaitez récupérer les automatisations.
Le nom de l’automatisation à récupérer.
Le nombre d’automatisations à récupérer par page. Valeur par défaut : 50. Il n’est généralement pas nécessaire de modifier cette valeur.
Curseur de pagination permettant de reprendre une requête antérieure, obtenu à partir de l’attribut `.cursor` d’un paginateur précédent.
Exemples
Récupérer toutes les automatisations existantes de l’entity "my-team" :
```python theme={"system"}
import wandb
api = wandb.Api()
automations = api.automations(entity="my-team")
```
méthode Api.create\_automation()
```python theme={"system"}
self,
obj: 'NewAutomation', *,
fetch_existing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'
```
Crée une nouvelle automatisation.
Arguments
L’automatisation à créer.
Si True et qu’une automatisation en conflit existe déjà, tente de récupérer l’automatisation existante au lieu de lever une erreur.
Aucune description fournie.
Exemples
Créez une automatisation nommée "my-automation" qui envoie une notification Slack
lorsqu’un run d’un projet donné journalise une métrique dépassant un seuil personnalisé :
```python theme={"system"}
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 de 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={"system"}
self,
entity: 'str',
name: 'str',
display_name: 'str',
spec_type: "Literal['vega2']",
access: "Literal['private', 'public']",
spec: 'str | dict'
```
Crée un préréglage de graphique personnalisé et renvoie son ID.
Arguments
L’entity (utilisateur ou équipe) propriétaire du graphique
Identifiant unique du préréglage de graphique
Nom lisible affiché dans l’interface utilisateur
Type de spécification. Doit être "vega2" pour les spécifications Vega-Lite v2.
Niveau d’accès au graphique :
* "private" : le graphique n’est accessible qu’à l’entity qui l’a créé
* "public" : le graphique est accessible publiquement
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={"system"}
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 le graphique 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={"system"}
self,
name: 'str',
entity: 'str'
```
Crée un nouveau projet.
Arguments
Le nom du nouveau projet.
L’entity du nouveau projet.
Le nom du registre. Ce nom doit être unique au sein de l’organisation.
La visibilité du registre. organization : tous les membres de l’organisation peuvent consulter ce registre. Vous pourrez modifier leurs rôles ultérieurement dans 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é.
L’organisation du registre. Si aucune organisation n’est définie dans les paramètres, elle est récupérée à partir de l’entity, à condition que celle-ci n’appartienne qu’à une seule organisation.
La description du registre.
Les types d’artifacts acceptés par le registre. Un type ne doit pas dépasser 128 caractères ni contenir les caractères `/` ou `:`. Si aucun type n’est spécifié, tous les types sont acceptés. Une fois ajoutés au registre, les types autorisés ne peuvent plus être supprimés.
Exemples
```python theme={"system"}
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"],
)
```
L’ID à attribuer au run. S’il n’est pas spécifié, W\&B génère un ID aléatoire.
Le projet dans lequel journaliser le run. Si aucun projet n’est spécifié, le run est journalisé dans un projet nommé « Uncategorized ».
L’entity propriétaire du projet. Si aucune entity n’est spécifiée, le run est journalisé dans l’entity par défaut.
méthode Api.create\_run\_queue()
```python theme={"system"}
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ée une nouvelle file d’attente de run dans W\&B Launch.
Arguments
Nom de la file d'attente à créer
Type de ressource à utiliser pour la file d'attente. Valeurs possibles : "local-container", "local-process", "kubernetes", "sagemaker" ou "gcp-vertex".
Nom de l'entity dans lequel créer la file d'attente. Si la valeur est `None`, l'entity configuré ou l'entity par défaut est utilisé.
Version de la priorisation à utiliser : "V0" ou `None`.
Configuration de ressources par défaut à utiliser pour la file d'attente. Utilisez la syntaxe handlebars (par ex. `{{var}}`) pour définir des variables de modèle.
Dictionnaire de schémas de variables de modèle à utiliser avec la configuration.
méthode Api.create\_team()
```python theme={"system"}
self,
team: 'str',
admin_username: 'str | None' = None
```
Crée une nouvelle équipe.
Si vous utilisez le Cloud mutualisé W\&B, définissez l’organisation API par défaut dans
vos paramètres utilisateur de l’interface W\&B avant d’appeler `create_team()`.
Ce paramètre détermine l’organisation à laquelle la nouvelle équipe sera rattachée.
Arguments
Le nom de l’équipe.
Nom d’utilisateur de l’administrateur de l’équipe. Par défaut, l’utilisateur actuel.
```python theme={"system"}
(self)
```
Vide le cache local.
L’objet api conserve un cache local des runs. Si l’état du run
est susceptible d’être modifié 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={"system"}
(self,
path: 'str')
```
Renvoie un run, un sweep, un projet ou un rapport à partir d’un chemin.
Arguments
Le chemin d’accès au projet, au run, au sweep ou au rapport
Exemples
Dans les extraits de code suivants, "project", "team", "run\_id", "sweep\_id"
et "report\_name" sont des espaces réservés qui désignent respectivement le projet, l’équipe, l’ID du run,
l’ID du sweep et le nom d’un rapport donné.
```python theme={"system"}
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={"system"}
self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie un itérateur sur toutes les intégrations d’une entity.
Arguments
L’entity (par exemple, le nom de l’équipe) pour lequel récupérer les intégrations. Si aucune valeur n’est fournie, l’entity par défaut de l’utilisateur est utilisé.
Nombre d’intégrations à récupérer par page. Valeur par défaut : 50. En règle générale, il n’y a aucune raison de modifier cette valeur.
Aucune description fournie.
Le nom de l’organisation. S’il est omis, cette méthode tente de déterminer et de renvoyer l’organisation par défaut actuelle.
méthode Api.project()
```python theme={"system"}
self,
name: 'str',
entity: 'str | None' = None
```
Renvoie le `Project` portant le nom indiqué (et appartenant à l’entity indiquée, le cas échéant).
Arguments
Le nom du projet.
Nom de l’entity demandé. Si la valeur est None, l’entity par défaut transmis à `Api` est utilisé. En l’absence d’entity par défaut, une `ValueError` est levée.
méthode Api.projects()
```python theme={"system"}
self,
entity: 'str | None' = None,
per_page: 'int' = 200
```
Obtenir les projets d’un entity donné.
Arguments
Nom de l’entity demandé. Si la valeur est None, l’entity par défaut transmis à `Api` est utilisé. En l’absence d’entity par défaut, une `ValueError` est levée.
Définit la taille de page pour la pagination des requêtes. En général, il n’y a aucune raison de modifier cette valeur.
méthode Api.queued\_run()
```python theme={"system"}
(self,
entity: 'str',
project: 'str',
queue_name: 'str',
run_queue_item_id: 'str', project_queue=None, priority=None)
```
Renvoie un run en file d'attente à partir du chemin indiqué.
Analyse les chemins au format `entity/project/queue_id/run_queue_item_id`.
```python theme={"system"}
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 paresseux d’objets `Registry`.
Utilisez l’itérateur pour rechercher et filtrer des registres, des collections
ou des versions d’artifact dans le registre de votre organisation. Les résultats sont
récupérés à la demande au fil de l’itération : vous pouvez donc vous arrêter après n’importe quel nombre
d’éléments (par exemple avec :func:`itertools.islice`) sans avoir à récupérer
le reste.
Arguments
L’organisation du registre à récupérer. Si elle n’est pas spécifiée, l’organisation définie dans les paramètres de l’utilisateur est utilisée.
Filtre facultatif de style MongoDB à appliquer à chaque objet de l’itérateur paresseux de registres. Les champs disponibles pour filtrer les registres sont `name`, `description`, `created_at` et `updated_at`. Les champs disponibles pour filtrer les collections sont `name`, `tag`, `description`, `created_at` et `updated_at`. Les champs disponibles pour filtrer les versions sont `tag`, `alias`, `created_at`, `updated_at` et `metadata`.
String facultative indiquant l’ordre de tri des résultats. Avec le préfixe « + », le tri est croissant (par défaut). Avec le préfixe « - », le tri est décroissant.
Définit la taille de page pour la pagination de la requête.
Curseur de pagination permettant de reprendre une requête antérieure, récupéré depuis l’attribut `.cursor` d’un paginateur précédent.
Exemples
Trouver tous les registres dont le nom contient « model »
```python theme={"system"}
import wandb
api = wandb.Api() # indiquez une organisation si votre entity appartient à plusieurs organisations
api.registries(filter={"name": {"$regex": "model"}})
```
Trouver, dans les registres, toutes les collections nommées "my\_collection" et portant le tag "my\_tag"
```python theme={"system"}
api.registries().collections(filter={"name": "my_collection", "tag": "my_tag"})
```
Trouver, dans les registres, toutes les versions d’artifact dont le nom de collection contient "my\_collection" et qui possèdent l’alias "best"
```python theme={"system"}
api.registries().collections(
filter={"name": {"$regex": "my_collection"}}
).versions(filter={"alias": "best"})
```
Trouver toutes les versions d’artifact dans les registres dont le nom contient "model" et qui ont le tag "prod" ou l’alias "best"
```python theme={"system"}
api.registries(filter={"name": {"$regex": "model"}}).versions(
filter={"$or": [{"tag": "prod"}, {"alias": "best"}]}
)
```
Suspendez l'itération et reprenez-la plus tard au même endroit en enregistrant
le `.cursor` du paginateur, puis en le transmettant via `start=` :
```python theme={"system"}
from itertools import islice
import wandb
api = wandb.Api()
# Parcourir la première page de résultats, puis enregistrer 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 enregistré.
remaining_registries = api.registries(per_page=page_size, start=saved_cursor)
```
méthode Api.registry()
```python theme={"system"}
self,
name: 'str',
organization: 'str | None' = None
```
Renvoie un registre à partir de son nom.
Arguments
Le nom du registre, sans le préfixe `wandb-registry-`.
L’organisation du registre. Si aucune organisation n’est définie dans les paramètres, l’organisation est déduite de l’entity, à condition que celle-ci n’appartienne qu’à une seule organisation.
Exemples
Récupérer et mettre à jour un registre
```python theme={"system"}
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={"system"}
self,
path: 'str' = '',
name: 'str | None' = None,
per_page: 'int' = 50
```
Obtenir les reports pour un chemin de projet donné.
Remarque : l’API `wandb.Api.reports()` est en version bêta et sera probablement modifiée dans
les prochaines versions.
Arguments
Chemin du projet contenant le rapport. Indiquez en préfixe l’entity qui a créé le projet, suivie d’une barre oblique.
Nom du rapport demandé.
Définit la taille de page pour la pagination des requêtes. En général, il n’y a aucune raison de modifier cette valeur.
```python theme={"system"}
self,
path: 'str' = ''
```
Renvoie un run unique en analysant un chemin au format `entity/project/run_id`.
Arguments
Chemin du run, au format `entity/project/run_id`. Si `api.entity` est défini, le chemin peut prendre la forme `project/run_id`, et si `api.project` est défini, il peut se limiter au run\_id.
Exceptions levées
* `RunNotFoundError` : si le run est introuvable ou si ses données ne peuvent pas être chargées.
méthode Api.run\_queue()
```python theme={"system"}
(self,
entity: 'str',
name: 'str')
```
Renvoie la `RunQueue` portant le nom indiqué pour l’entity.
Voir `Api.create_run_queue` pour plus d’informations sur la création d’une file d’attente de run.
```python theme={"system"}
(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 manière différée sur des objets `Run`.
Vous pouvez filtrer sur les champs suivants :
* `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 d’exécution totale du run, en secondes.
* `group` : le nom du groupe utilisé pour regrouper des runs liés.
* `host` : le nom d’hôte de la machine sur laquelle le run a été exécuté.
* `jobType` : le type de job ou l’objectif 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 de l’utilisateur qui a lancé le run
Vous pouvez également filtrer sur les éléments de la configuration de run ou des métriques de synthèse,
comme `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
(str) chemin vers le projet, au format : "entity/project"
(dict) requêtes ciblant des runs spécifiques à l’aide du langage de requête MongoDB. Vous pouvez filtrer selon des propriétés de run telles que config.key, summary\_metrics.key, state, entity, createdAt, etc. Par exemple, `{"config.experiment_name": "foo"}` renvoie les runs dont l’entrée de configuration experiment name est définie sur "foo"
(str) L’ordre de tri peut être `created_at`, `heartbeat_at`, `config.*.value` ou `summary_metrics.*`. Si vous le préfixez par un +, le tri est croissant (par défaut). Si vous le préfixez par un -, le tri est décroissant. L’ordre par défaut est run.created\_at, du plus ancien au plus récent.
(int) Définit la taille de page pour la pagination des requêtes.
(bool) Indique s’il faut récupérer immédiatement l’objet sweep dans chaque résultat de run.
(bool) Indique s’il faut utiliser le chargement différé pour améliorer les performances. Lorsque la valeur est True (par défaut), seules les métadonnées essentielles du run sont chargées au départ. Les champs volumineux comme config, summaryMetrics et systemMetrics sont chargés à la demande, lors de leur premier accès. Définissez la valeur sur False pour charger l’ensemble des données dès le départ.
Exemples
```python theme={"system"}
import wandb
from wandb.apis.public import Api
# Trouver les runs du projet dont config.experiment_name est défini sur "foo"
Api.runs(path="my_entity/project", filters={"config.experiment_name": "foo"})
```
```python theme={"system"}
# Trouver les runs du projet dont config.experiment_name est défini sur "foo" ou "bar"
Api.runs(
path="my_entity/project",
filters={
"$or": [
{"config.experiment_name": "foo"},
{"config.experiment_name": "bar"},
]
},
)
```
```python theme={"system"}
# Trouver les runs du projet dont 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 syntaxe RE2 de Google :
[https://github.com/google/re2/wiki/Syntax](https://github.com/google/re2/wiki/Syntax)
```python theme={"system"}
# Trouver les runs du projet dont le nom correspond à une regex
Api.runs(
path="my_entity/project", filters={"display_name": {"$regex": "^foo.*"}}
)
```
```python theme={"system"}
# Trouver les runs du projet, triés par ordre croissant de perte
Api.runs(path="my_entity/project", order="+summary_metrics.loss")
```
méthode Api.slack\_integrations()
```python theme={"system"}
self, *,
entity: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie un itérateur sur les intégrations Slack d’une entity.
Arguments
L’entity (par exemple, le nom d’une équipe) pour lequel récupérer les intégrations. S’il n’est pas fourni, l’entity par défaut de l’utilisateur est utilisé.
Nombre d’intégrations à récupérer par page. Valeur par défaut : 50. En règle générale, il n’y a aucune raison de modifier cette valeur.
Aucune description fournie.
Exemples
Obtenir toutes les intégrations Slack enregistrées pour l’équipe "my-team" :
```python theme={"system"}
import wandb
api = wandb.Api()
slack_integrations = api.slack_integrations(entity="my-team")
```
Trouver uniquement les intégrations Slack qui publient dans des canaux dont le nom commence par "team-alerts-" :
```python theme={"system"}
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={"system"}
(self, path='')
```
Renvoie un sweep en analysant le chemin au format `entity/project/sweep_id`.
Arguments
Chemin du sweep, au format entity/project/sweep\_id. Si `api.entity` est défini, le chemin peut prendre la forme project/sweep\_id ; si `api.project` est défini, il peut se limiter au sweep\_id.
méthode Api.sync\_tensorboard()
```python theme={"system"}
(self, root_dir, run_id=None, project=None, entity=None)
```
Synchronise un répertoire local contenant des fichiers tfevent avec wandb.
```python theme={"system"}
self,
team: 'str'
```
Renvoie l’objet `Team` correspondant au nom indiqué.
Arguments
Le nom de l’équipe.
méthode Api.update\_automation()
```python theme={"system"}
self,
obj: 'Automation', *,
create_missing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'
```
Met à jour une automatisation existante.
Arguments
L’automatisation à mettre à jour. Elle doit déjà exister.
Si `True` et que l’automatisation n’existe pas, celle-ci est créée.
Aucune description fournie.
Exemples
Désactiver une automatisation existante ("my-automation") et modifier sa description :
```python theme={"system"}
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={"system"}
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={"system"}
(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
Nom de la file d'attente à créer
Configuration de ressources par défaut (facultative) à utiliser pour la file d'attente. Utilisez la syntaxe handlebars (par ex. `{{var}}`) pour définir des variables de modèle.
Type de ressource à utiliser pour la file d'attente. Valeurs possibles : "local-container", "local-process", "kubernetes", "sagemaker" ou "gcp-vertex".
Nom facultatif de l'entity dans lequel créer la file d'attente. Si la valeur est `None`, l'entity configuré ou l'entity par défaut est utilisé.
Dictionnaire de schémas de variables de modèle à utiliser avec la configuration.
Dictionnaire facultatif de liens externes à associer à la file d'attente.
Version facultative du mode de priorisation à utiliser. Soit "V0", soit None
méthode Api.user()
```python theme={"system"}
self,
username_or_email: 'str'
```
Renvoie un utilisateur à partir d’un nom d’utilisateur ou d’une adresse e-mail.
Cette fonction n’est disponible que pour les administrateurs locaux. Utilisez `api.viewer`
pour obtenir votre propre objet utilisateur.
Arguments
Le nom d’utilisateur ou l’adresse e-mail de l’utilisateur.
méthode Api.users()
```python theme={"system"}
self,
username_or_email: 'str'
```
Renvoie tous les utilisateurs correspondant à une requête sur un nom d’utilisateur ou une adresse e-mail partiel.
Cette fonction n’est disponible que pour les administrateurs locaux. Utilisez `api.viewer`
pour obtenir votre propre objet utilisateur.
Arguments
Le préfixe ou le suffixe de l’utilisateur à rechercher.
méthode Api.webhook\_integrations()
```python theme={"system"}
self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None
```
Renvoie un itérateur sur les intégrations webhook d’un entity.
Arguments
L’entity (par exemple, le nom de l’équipe) pour lequel récupérer les intégrations. S’il n’est pas fourni, l’entity par défaut de l’utilisateur est utilisé.
Nombre d’intégrations à récupérer par page. Valeur par défaut : 50. En général, il n’y a aucune raison de modifier cette valeur.
Aucune description fournie.
Exemples
Obtenir toutes les intégrations webhook enregistrées pour l’équipe "my-team" :
```python theme={"system"}
import wandb
api = wandb.Api()
webhook_integrations = api.webhook_integrations(entity="my-team")
```
Trouver uniquement les intégrations webhook qui envoient des requêtes à "[https://my-fake-url.com](https://my-fake-url.com)" :
```python theme={"system"}
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")
]
```
## Related topics
- [API](/fr/support/models/tags/api.md)