Api

Api(
    overrides: Optional[Dict[str, Any]] = None,
    timeout: Optional[int] = None,
    api_key: Optional[str] = None
) -> None

>>> wandb.Api()

artifact(
    name: str,
    type: Optional[str] = None
)

artifact_collection(
    type_name: str,
    name: str
) -> "public.ArtifactCollection"

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

artifact_collections(
    project_name: str,
    type_name: str,
    per_page: Optional[int] = 50
) -> "public.ArtifactCollections"

artifact_exists(
    name: str,
    type: Optional[str] = None
) -> bool

artifact_type(
    type_name: str,
    project: Optional[str] = None
) -> "public.ArtifactType"

artifact_types(
    project: Optional[str] = None
) -> "public.ArtifactTypes"

artifact_versions(
    type_name, name, per_page=50
)

artifacts(
    type_name: str,
    name: str,
    per_page: Optional[int] = 50,
    tags: Optional[List[str]] = None
) -> "public.Artifacts"

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

create_run(
    *,
    run_id: Optional[str] = None,
    project: Optional[str] = None,
    entity: Optional[str] = None
) -> "public.Run"

create_run_queue(
    name: str,
    type: "public.RunQueueResourceType",
    entity: Optional[str] = None,
    prioritization_mode: Optional['public.RunQueuePrioritizationMode'] = None,
    config: Optional[dict] = None,
    template_variables: Optional[dict] = None
) -> "public.RunQueue"

create_team(
    team, admin_username=None
)

create_user(
    email, admin=(False)
)

flush()

from_path(
    path
)

project = api.from_path("my_project")
team_project = api.from_path("my_team/my_project")
run = api.from_path("my_team/my_project/runs/id")
sweep = api.from_path("my_team/my_project/sweeps/id")
report = api.from_path("my_team/my_project/reports/My-Report-Vm11dsdf")

job(
    name: Optional[str],
    path: Optional[str] = None
) -> "public.Job"

list_jobs(
    entity: str,
    project: str
) -> List[Dict[str, Any]]

project(
    name: str,
    entity: Optional[str] = None
) -> "public.Project"

projects(
    entity: Optional[str] = None,
    per_page: Optional[int] = 200
) -> "public.Projects"

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

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

import wandb

api = wandb.Api()  # entity가 여러 조직에 속한 경우 조직을 지정합니다.
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"}]}
)

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

run(
    path=""
)

run_queue(
    entity, name
)

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

api.runs(
    path="my_entity/my_project",
    filters={"config.experiment_name": "foo"},
)

api.runs(
    path="my_entity/my_project",
    filters={
        "$or": [
            {"config.experiment_name": "foo"},
            {"config.experiment_name": "bar"},
        ]
    },
)

api.runs(
    path="my_entity/my_project",
    filters={"config.experiment_name": {"$regex": "b.*"}},
)

api.runs(
    path="my_entity/my_project",
    filters={"display_name": {"$regex": "^foo.*"}},
)

api.runs(
    path="my_entity/my_project",
    filters={"config.experiment.category": "testing"},
)

api.runs(
    path="my_entity/my_project",
    filters={"summary_metrics.model1.loss": 0.5},
)

api.runs(path="my_entity/my_project", order="+summary_metrics.loss")

sweep(
    path=""
)

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

team(
    team: str
) -> "public.Team"

upsert_run_queue(
    name: str,
    resource_config: dict,
    resource_type: "public.RunQueueResourceType",
    entity: Optional[str] = None,
    template_variables: Optional[dict] = None,
    external_links: Optional[dict] = None,
    prioritization_mode: Optional['public.RunQueuePrioritizationMode'] = None
)

user(
    username_or_email: str
) -> Optional['public.User']

users(
    username_or_email: str
) -> List['public.User']