Api

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.

​

class Api

import wandb

wandb.Api()

​

méthode Api.__init__

__init__(
    overrides: 'dict[str, Any] | None' = None,
    timeout: 'int | None' = None,
    api_key: 'str | None' = 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.

​

propriété Api.client

• RetryingClient : La valeur de la propriété client.

​

propriété Api.default_entity

• str | None: La valeur de la propriété default_entity.

​

propriété Api.user_agent

• str: La valeur de la propriété user_agent.

​

propriété Api.viewer

• ValueError : Si les données du viewer ne peuvent pas être récupérées depuis W&B.
• requests.RequestException : Si une erreur survient lors de la requête GraphQL.

• User : La valeur de la propriété viewer.

​

méthode Api.artifact

artifact(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é.

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

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

artifact_collection(type_name: 'str', name: 'str') → ArtifactCollection

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

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

artifact_collection_exists(name: 'str', type: 'str') → bool

• 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

artifact_collections(
    project_name: 'str',
    type_name: 'str',
    per_page: 'int' = 50,
    start: 'str | None' = None
) → ArtifactCollections

• project_name: Le nom du projet à utiliser pour le filtrage.
• type_name: Le nom du type d’artifact à utiliser pour le filtrage.
• 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

artifact_exists(name: 'str', type: 'str | None' = None) → bool

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

import wandb

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

​

méthode Api.artifact_type

artifact_type(type_name: 'str', project: 'str | None' = None) → ArtifactType

• 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

artifact_types(
    project: 'str | None' = None,
    start: 'str | None' = None
) → ArtifactTypes

• 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

artifact_versions(type_name, name, per_page=50)

​

méthode Api.artifacts

artifacts(
    type_name: 'str',
    name: 'str',
    per_page: 'int' = 50,
    tags: 'list[str] | None' = None,
    start: 'str | None' = None
) → Artifacts

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

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

automation(name: 'str', entity: 'str | None' = None) → Automation

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

import wandb

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

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

​

méthode Api.automations

automations(
    entity: 'str | None' = None,
    name: 'str | None' = None,
    per_page: 'int' = 50,
    start: 'str | None' = None
) → Iterator[Automation]

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

import wandb

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

​

méthode Api.create_automation

create_automation(
    obj: 'NewAutomation',
    fetch_existing: 'bool' = False,
    **kwargs: 'Unpack[WriteAutomationsKwargs]'
) → Automation

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

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

create_custom_chart(
    entity: 'str',
    name: 'str',
    display_name: 'str',
    spec_type: "Literal['vega2']",
    access: "Literal['private', 'public']",
    spec: 'str | dict'
) → str

• 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

    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

create_project(name: 'str', entity: 'str') → None

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

​

méthode Api.create_registry

create_registry(
    name: 'str',
    visibility: "Literal['organization', 'restricted']",
    organization: 'str | None' = None,
    description: 'str | None' = None,
    artifact_types: 'list[str] | None' = None
) → Registry

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

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

create_run(
    run_id: 'str | None' = None,
    project: 'str | None' = None,
    entity: 'str | None' = None
) → public.Run

• 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

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

• 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

create_team(team: 'str', admin_username: 'str | None' = None) → Team

• 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

create_user(email: 'str', admin: 'bool | None' = False) → User

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

​

méthode Api.delete_automation

delete_automation(obj: 'Automation | str') → Literal[True]

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

​

méthode Api.flush

flush()

​

méthode Api.from_path

from_path(path: 'str')

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

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

integrations(
    entity: 'str | None' = None,
    per_page: 'int' = 50,
    start: 'str | None' = None
) → Iterator[Integration]

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

• Iterator[SlackIntegration | WebhookIntegration]: Un itérateur de toutes les intégrations prises en charge.

​

méthode Api.job

job(name: 'str | None', path: 'str | None' = None) → public.Job

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

​

méthode Api.list_jobs

list_jobs(entity: 'str', project: 'str') → list[dict[str, Any]]

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

​

méthode Api.project

project(name: 'str', entity: 'str | None' = None) → public.Project

• 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

projects(entity: 'str | None' = None, per_page: 'int' = 200) → public.Projects

• 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

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

​

méthode Api.registries

registries(
    organization: 'str | None' = None,
    filter: 'dict[str, Any] | None' = None,
    per_page: 'int' = 100,
    start: 'str | None' = None
) → Registries

• organization: (str, facultatif) 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: (dict, facultatif) 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
• 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.

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

registry(name: 'str', organization: 'str | None' = None) → Registry

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

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

reports(
    path: 'str' = '',
    name: 'str | None' = None,
    per_page: 'int' = 50
) → public.Reports

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

import wandb

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

​

méthode Api.run

run(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.

​

méthode Api.run_queue

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

​

méthode Api.runs

runs(
    path: 'str | None' = None,
    filters: 'dict[str, Any] | None' = None,
    order: 'str' = '+created_at',
    per_page: 'int' = 50,
    include_sweeps: '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.
• 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 inclure les runs de balayage dans les résultats.
• 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.

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
# (les ancres ne sont pas prises en charge)
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
# (les ancres ne sont pas prises en charge)
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

slack_integrations(
    entity: 'str | None' = None,
    per_page: 'int' = 50,
    start: 'str | None' = None
) → Iterator[SlackIntegration]

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

• Iterator[SlackIntegration] : Un itérateur d’intégrations Slack.

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

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

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

​

méthode Api.team

team(team: 'str') → Team

• team : le nom de l’équipe.

​

méthode Api.update_automation

update_automation(
    obj: 'Automation',
    create_missing: 'bool' = False,
    **kwargs: 'Unpack[WriteAutomationsKwargs]'
) → Automation

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

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

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
)

• 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

​

méthode Api.user

user(username_or_email: 'str') → User | None

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

​

méthode Api.users

users(username_or_email: 'str') → list[User]

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

​

méthode Api.webhook_integrations

webhook_integrations(
    entity: 'str | None' = None,
    per_page: 'int' = 50,
    start: 'str | None' = None
) → Iterator[WebhookIntegration]

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

• Iterator[WebhookIntegration] : Un itérateur d’intégrations webhook.

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