Api

import wandb

wandb.Api()

artifact(
    name: str,
    type: (str | None) = None
)

import wandb

# Specify the project, artifact's name, and the artifact's alias
wandb.Api().artifact(name="project/artifact:alias")

# Specify the project, artifact's name, and a specific artifact version
wandb.Api().artifact(name="project/artifact:version")

# Specify the entity, project, artifact's name, and the artifact's alias
wandb.Api().artifact(name="entity/project/artifact:alias")

# Specify the entity, project, artifact's name, and a specific artifact version
wandb.Api().artifact(name="entity/project/artifact:version")

artifact_collection(
    type_name: str,
    name: str
) -> ArtifactCollection

import wandb

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

# Get the first artifact in the collection
artifact_example = collections.artifacts()[0]

# Download the contents of the artifact to the specified root directory.
artifact_example.download()

artifact_collection_exists(
    name: str,
    type: str
) -> bool

import wandb

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

artifact_collections(
    project_name: str,
    type_name: str,
    per_page: int = 50
) -> ArtifactCollections

artifact_exists(
    name: str,
    type: (str | None) = None
) -> bool

import wandb

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

artifact_type(
    type_name: str,
    project: (str | None) = None
) -> ArtifactType

artifact_types(
    project: (str | None) = None
) -> ArtifactTypes

artifact_versions(
    type_name, name, per_page=50
)

artifacts(
    type_name: str,
    name: str,
    per_page: int = 50,
    tags: (list[str] | None) = None
) -> Artifacts

import wandb

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

automation(
    name: str,
    *,
    entity: (str | None) = None
) -> Automation

import wandb

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

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

automations(
    entity: (str | None) = None,
    *,
    name: (str | None) = None,
    per_page: int = 50
) -> Iterator[Automation]

import wandb

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

create_automation(
    obj: NewAutomation,
    *,
    fetch_existing: bool = (False),
    **kwargs
) -> Automation

import wandb
from wandb.automations import OnRunMetric, RunEvent, SendNotification

api = wandb.Api()

project = api.project("my-project", entity="my-team")

# Use the first Slack integration for the team
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.",
)

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

import wandb

api = wandb.Api()

# Define a simple bar chart specification
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"},
    },
}

# Create the custom chart
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,
)

# Use with wandb.plot_table()
chart = wandb.plot_table(
    vega_spec_name=chart_id,
    data_table=my_table,
    fields={"x": "category", "y": "value"},
)

create_project(
    name: str,
    entity: str
) -> None

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

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

create_run(
    *,
    run_id: (str | None) = None,
    project: (str | None) = None,
    entity: (str | None) = None
) -> public.Run

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

create_team(
    team: str,
    admin_username: (str | None) = None
) -> Team

create_user(
    email: str,
    admin: (bool | None) = (False)
) -> User

delete_automation(
    obj: (Automation | str)
) -> Literal[True]

flush()

from_path(
    path: str
)

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

integrations(
    entity: (str | None) = None,
    *,
    per_page: int = 50
) -> Iterator[Integration]

job(
    name: (str | None),
    path: (str | None) = None
) -> public.Job

list_jobs(
    entity: str,
    project: str
) -> list[dict[str, Any]]

project(
    name: str,
    entity: (str | None) = None
) -> public.Project

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

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

registries(
    organization: (str | None) = None,
    filter: (dict[str, Any] | None) = None
) -> Registries

import wandb

api = wandb.Api()  # specify an org if your entity belongs to multiple orgs
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"}]}
)

registry(
    name: str,
    organization: (str | None) = None
) -> Registry

import wandb

api = wandb.Api()
registry = api.registry(name="my-registry", organization="my-org")
registry.description = "This is an updated description"
registry.save()

reports(
    path: str = "",
    name: (str | None) = None,
    per_page: int = 50
) -> public.Reports

import wandb

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

run(
    path=""
)

run_queue(
    entity: str,
    name: str
)

runs(
    path: (str | None) = None,
    filters: (dict[str, Any] | None) = None,
    order: str = "+created_at",
    per_page: int = 50,
    include_sweeps: bool = (True),
    lazy: bool = (True)
)

# Find runs in project where config.experiment_name has been set to "foo"
api.runs(path="my_entity/project", filters={"config.experiment_name": "foo"})

# Find runs in project where config.experiment_name has been set to "foo" or "bar"
api.runs(
    path="my_entity/project",
    filters={
        "$or": [
            {"config.experiment_name": "foo"},
            {"config.experiment_name": "bar"},
        ]
    },
)

# Find runs in project where config.experiment_name matches a regex
# (anchors are not supported)
api.runs(
    path="my_entity/project",
    filters={"config.experiment_name": {"$regex": "b.*"}},
)

# Find runs in project where the run name matches a regex
# (anchors are not supported)
api.runs(
    path="my_entity/project", filters={"display_name": {"$regex": "^foo.*"}}
)

# Find runs in project sorted by ascending loss
api.runs(path="my_entity/project", order="+summary_metrics.loss")

slack_integrations(
    *,
    entity: (str | None) = None,
    per_page: int = 50
) -> Iterator[SlackIntegration]

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

sweep(
    path=""
)

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

team(
    team: str
) -> Team

update_automation(
    obj: Automation,
    *,
    create_missing: bool = (False),
    **kwargs
) -> Automation

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

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
)

user(
    username_or_email: str
) -> (User | None)

users(
    username_or_email: str
) -> list[User]

webhook_integrations(
    entity: (str | None) = None,
    *,
    per_page: int = 50
) -> Iterator[WebhookIntegration]

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