Api

​

classe wandb.Api

overrides: 'dict[str, Any] | None' = None,
timeout: 'int | None' = None,
api_key: 'str | None' = None

• 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

import wandb

wandb.Api()

​

propriété default_entity

​

propriété user_agent

​

propriété viewer

​

méthode Api.artifact()

(self,
name: 'str',
type: 'str | None' = None)

• 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.

• 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

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

self,
type_name: 'str',
name: 'str'

• 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

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

self,
name: 'str',
type: 'str'

• 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.

import wandb

wandb.Api.artifact_collection_exists(type="type", name="collection_name")

​

méthode Api.artifact_collections()

self,
project_name: 'str',
type_name: 'str',
order: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None

• 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()

self,
name: 'str',
type: 'str | None' = None

• 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

import wandb

wandb.Api().artifact_exists("entity/project/artifact:version")
wandb.Api().artifact_exists("entity/project/artifact:alias")

​

méthode Api.artifact_type()

self,
type_name: 'str',
project: 'str | None' = None

• 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()

self,
project: 'str | None' = None,
start: 'str | None' = None

• 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()

(self, type_name, name, per_page=50)

• type_name:
• name:
• per_page:

​

méthode Api.artifacts()

self,
type_name: 'str',
name: 'str',
order: 'str | None' = None,
per_page: 'int' = 50,
tags: 'list[str] | None' = None,
start: 'str | None' = None

• 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

import wandb

wandb.Api().artifacts(type_name="type", name="entity/project/artifact_name")

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

self,
name: 'str', *,
entity: 'str | None' = None

• name: Le nom de l’automatisation à récupérer.
• entity: L’entité pour laquelle récupérer l’automatisation.

• ValueError: Si aucune ou plusieurs automatisations correspondent aux critères de recherche.

Exemples

import wandb

api = wandb.Api()
automation = api.automation(name="my-automation")

automation = api.automation(name="other-automation", entity="my-team")

​

méthode Api.automations()

self,
entity: 'str | None' = None, *,
name: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None

• 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

import wandb

api = wandb.Api()
automations = api.automations(entity="my-team")

​

méthode Api.create_automation()

self,
obj: 'NewAutomation', *,
fetch_existing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'

• 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

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

self,
entity: 'str',
name: 'str',
display_name: 'str',
spec_type: "Literal['vega2']",
access: "Literal['private', 'public']",
spec: 'str | dict'

• 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

• wandb.Error: Si la création du graphique échoue
• UnsupportedError: Si le serveur ne prend pas en charge les graphiques personnalisés

Exemples

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

self,
name: 'str',
entity: 'str'

• name: Le nom du nouveau projet.
• entity: L’entité du nouveau projet.

​

méthode Api.create_registry()

self,
name: 'str',
visibility: "Literal['organization', 'restricted']",
organization: 'str | None' = None,
description: 'str | None' = None,
artifact_types: 'list[str] | None' = None

• 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

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

self, *,
run_id: 'str | None' = None,
project: 'str | None' = None,
entity: 'str | None' = None

• 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()

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

• 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()

self,
team: 'str',
admin_username: 'str | None' = None

• 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()

self,
email: 'str',
admin: 'bool | None' = False

• email: L’adresse e-mail de l’utilisateur.
• admin: Définit l’utilisateur comme administrateur global de l’instance.

​

méthode Api.delete_automation()

self,
obj: 'Automation | str'

• obj : l’automatisation à supprimer, ou son ID.

​

méthode Api.flush()

(self)

​

méthode Api.from_path()

(self,
path: 'str')

• path: Le chemin vers le projet, le run, le balayage ou le rapport

Exemples

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

self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None

• 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()

self,
name: 'str | None',
path: 'str | None' = None

• name : Le nom du job.
• path : Le chemin racine à partir duquel télécharger l’artifact du job.

​

méthode Api.list_jobs()

self,
entity: 'str',
project: 'str'

• entity: L’entité associée aux jobs listés.
• project: Le projet associé aux jobs listés.

​

méthode Api.organization()

self,
name: 'str | None' = None

• 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()

self,
name: 'str',
entity: 'str | None' = None

• 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()

self,
entity: 'str | None' = None,
per_page: 'int' = 200

• 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()

(self,
entity: 'str',
project: 'str',
queue_name: 'str',
run_queue_item_id: 'str', project_queue=None, priority=None)

• entity:
• project:
• queue_name:
• run_queue_item_id:
• project_queue:
• priority:

​

méthode Api.registries()

self,
organization: 'str | None' = None,
filter: 'dict[str, Any] | None' = None,
order: 'str | None' = None,
per_page: 'int' = 100,
start: 'str | None' = None

• 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

import wandb

api = wandb.Api()  # spécifiez une organisation si votre entité appartient à plusieurs organisations
api.registries(filter={"name": {"$regex": "model"}})

api.registries().collections(filter={"name": "my_collection", "tag": "my_tag"})

api.registries().collections(
    filter={"name": {"$regex": "my_collection"}}
).versions(filter={"alias": "best"})

api.registries(filter={"name": {"$regex": "model"}}).versions(
    filter={"$or": [{"tag": "prod"}, {"alias": "best"}]}
)

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

self,
name: 'str',
organization: 'str | None' = None

• 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

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

self,
path: 'str' = '',
name: 'str | None' = None,
per_page: 'int' = 50

• 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

import wandb

wandb.Api.reports("entity/project")

​

méthode Api.run()

(self, path='')

• 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.

• RunNotFoundError : Si une run est introuvable ou si ses données ne peuvent pas être chargées.

​

méthode Api.run_queue()

(self,
entity: 'str',
name: 'str')

• entity:
• name:

​

méthode Api.runs()

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

• 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

• $and
• $or
• $nor
• $eq
• $ne
• $gt
• $gte
• $lt
• $lte
• $in
• $nin
• $exists
• $regex

• 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

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

# 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"},
        ]
    },
)

# 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.*"}},
)

# 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.*"}}
)

# 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()

self, *,
entity: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None

• 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

import wandb

api = wandb.Api()
slack_integrations = api.slack_integrations(entity="my-team")

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

(self, path='')

• 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()

(self, root_dir, run_id=None, project=None, entity=None)

• root_dir:
• run_id:
• project:
• entity:

​

méthode Api.team()

self,
team: 'str'

• team : le nom de l’équipe.

​

méthode Api.update_automation()

self,
obj: 'Automation', *,
create_missing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'

• 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

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)

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

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

• 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()

self,
username_or_email: 'str'

• username_or_email: Le nom d’utilisateur ou l’adresse e-mail de l’utilisateur.

​

méthode Api.users()

self,
username_or_email: 'str'

• username_or_email: Le préfixe ou le suffixe de l’utilisateur que vous souhaitez trouver.

​

méthode Api.webhook_integrations()

self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None

• 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

import wandb

api = wandb.Api()
webhook_integrations = api.webhook_integrations(entity="my-team")

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