wandb 0.18.3__py3-none-win_amd64.whl → 0.18.5__py3-none-win_amd64.whl

wandb/apis/public/runs.py

@@ -753,11 +753,62 @@ class Run(Attrs):
             )
 
     @normalize_exceptions
-    def logged_artifacts(self, per_page=100):
+    def logged_artifacts(self, per_page: int = 100) -> public.RunArtifacts:
+        """Fetches all artifacts logged by this run.
+
+        Retrieves all output artifacts that were logged during the run. Returns a
+        paginated result that can be iterated over or collected into a single list.
+
+        Args:
+            per_page: Number of artifacts to fetch per API request.
+
+        Returns:
+            An iterable collection of all Artifact objects logged as outputs during this run.
+
+        Example:
+            >>> import wandb
+            >>> import tempfile
+            >>> with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as tmp:
+            ...     tmp.write("This is a test artifact")
+            ...     tmp_path = tmp.name
+            >>> run = wandb.init(project="artifact-example")
+            >>> artifact = wandb.Artifact("test_artifact", type="dataset")
+            >>> artifact.add_file(tmp_path)
+            >>> run.log_artifact(artifact)
+            >>> run.finish()
+            >>> api = wandb.Api()
+            >>> finished_run = api.run(f"{run.entity}/{run.project}/{run.id}")
+            >>> for logged_artifact in finished_run.logged_artifacts():
+            ...     print(logged_artifact.name)
+            test_artifact
+        """
         return public.RunArtifacts(self.client, self, mode="logged", per_page=per_page)
 
     @normalize_exceptions
-    def used_artifacts(self, per_page=100):
+    def used_artifacts(self, per_page: int = 100) -> public.RunArtifacts:
+        """Fetches artifacts explicitly used by this run.
+
+        Retrieves only the input artifacts that were explicitly declared as used
+        during the run, typically via `run.use_artifact()`. Returns a paginated
+        result that can be iterated over or collected into a single list.
+
+        Args:
+            per_page: Number of artifacts to fetch per API request.
+
+        Returns:
+            An iterable collection of Artifact objects explicitly used as inputs in this run.
+
+        Example:
+            >>> import wandb
+            >>> run = wandb.init(project="artifact-example")
+            >>> run.use_artifact("test_artifact:latest")
+            >>> run.finish()
+            >>> api = wandb.Api()
+            >>> finished_run = api.run(f"{run.entity}/{run.project}/{run.id}")
+            >>> for used_artifact in finished_run.used_artifacts():
+            ...     print(used_artifact.name)
+            test_artifact
+        """
         return public.RunArtifacts(self.client, self, mode="used", per_page=per_page)
 
     @normalize_exceptions

wandb/cli/beta.py

@@ -0,0 +1,178 @@
+"""Beta versions of wandb CLI commands.
+
+These commands are experimental and may change or be removed in future versions.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+import click
+
+import wandb
+from wandb.errors import UsageError, WandbCoreNotAvailableError
+from wandb.util import get_core_path
+
+
+@click.group()
+def beta():
+    """Beta versions of wandb CLI commands. Requires wandb-core."""
+    # this is the future that requires wandb-core!
+    import wandb.env
+
+    wandb._sentry.configure_scope(process_context="wandb_beta")
+
+    if wandb.env.is_require_legacy_service():
+        raise UsageError(
+            "wandb beta commands can only be used with wandb-core. "
+            f"Please make sure that `{wandb.env._REQUIRE_LEGACY_SERVICE}` is not set."
+        )
+
+    try:
+        get_core_path()
+    except WandbCoreNotAvailableError as e:
+        wandb._sentry.exception(f"using `wandb beta`. failed with {e}")
+        click.secho(
+            (e),
+            fg="red",
+            err=True,
+        )
+
+
+@beta.command(
+    name="sync",
+    context_settings={"default_map": {}},
+    help="Upload a training run to W&B",
+)
+@click.pass_context
+@click.argument("wandb_dir", nargs=1, type=click.Path(exists=True))
+@click.option("--id", "run_id", help="The run you want to upload to.")
+@click.option("--project", "-p", help="The project you want to upload to.")
+@click.option("--entity", "-e", help="The entity to scope to.")
+@click.option("--skip-console", is_flag=True, default=False, help="Skip console logs")
+@click.option("--append", is_flag=True, default=False, help="Append run")
+@click.option(
+    "--include",
+    "-i",
+    help="Glob to include. Can be used multiple times.",
+    multiple=True,
+)
+@click.option(
+    "--exclude",
+    "-e",
+    help="Glob to exclude. Can be used multiple times.",
+    multiple=True,
+)
+@click.option(
+    "--mark-synced/--no-mark-synced",
+    is_flag=True,
+    default=True,
+    help="Mark runs as synced",
+)
+@click.option(
+    "--skip-synced/--no-skip-synced",
+    is_flag=True,
+    default=True,
+    help="Skip synced runs",
+)
+@click.option(
+    "--dry-run", is_flag=True, help="Perform a dry run without uploading anything."
+)
+def sync_beta(  # noqa: C901
+    ctx,
+    wandb_dir=None,
+    run_id: str | None = None,
+    project: str | None = None,
+    entity: str | None = None,
+    skip_console: bool = False,
+    append: bool = False,
+    include: str | None = None,
+    exclude: str | None = None,
+    skip_synced: bool = True,
+    mark_synced: bool = True,
+    dry_run: bool = False,
+) -> None:
+    import concurrent.futures
+    from multiprocessing import cpu_count
+
+    paths = set()
+
+    # TODO: test file discovery logic
+    # include and exclude globs are evaluated relative to the provided base_path
+    if include:
+        for pattern in include:
+            matching_dirs = list(pathlib.Path(wandb_dir).glob(pattern))
+            for d in matching_dirs:
+                if not d.is_dir():
+                    continue
+                wandb_files = [p for p in d.glob("*.wandb") if p.is_file()]
+                if len(wandb_files) > 1:
+                    print(f"Multiple wandb files found in directory {d}, skipping")
+                elif len(wandb_files) == 1:
+                    paths.add(d)
+    else:
+        paths.update({p.parent for p in pathlib.Path(wandb_dir).glob("**/*.wandb")})
+
+    for pattern in exclude:
+        matching_dirs = list(pathlib.Path(wandb_dir).glob(pattern))
+        for d in matching_dirs:
+            if not d.is_dir():
+                continue
+            if d in paths:
+                paths.remove(d)
+
+    # remove paths that are already synced, if requested
+    if skip_synced:
+        synced_paths = set()
+        for path in paths:
+            wandb_synced_files = [p for p in path.glob("*.wandb.synced") if p.is_file()]
+            if len(wandb_synced_files) > 1:
+                print(
+                    f"Multiple wandb.synced files found in directory {path}, skipping"
+                )
+            elif len(wandb_synced_files) == 1:
+                synced_paths.add(path)
+        paths -= synced_paths
+
+    if run_id and len(paths) > 1:
+        # TODO: handle this more gracefully
+        click.echo("id can only be set for a single run.", err=True)
+        sys.exit(1)
+
+    if not paths:
+        click.echo("No runs to sync.")
+        return
+
+    click.echo("Found runs:")
+    for path in paths:
+        click.echo(f"  {path}")
+
+    if dry_run:
+        return
+
+    wandb.sdk.wandb_setup.setup()
+
+    # TODO: make it thread-safe in the Rust code
+    with concurrent.futures.ProcessPoolExecutor(
+        max_workers=min(len(paths), cpu_count())
+    ) as executor:
+        futures = []
+        for path in paths:
+            # we already know there is only one wandb file in the directory
+            wandb_file = [p for p in path.glob("*.wandb") if p.is_file()][0]
+            future = executor.submit(
+                wandb._sync,
+                wandb_file,
+                run_id=run_id,
+                project=project,
+                entity=entity,
+                skip_console=skip_console,
+                append=append,
+                mark_synced=mark_synced,
+            )
+            futures.append(future)
+
+        # Wait for tasks to complete
+        for _ in concurrent.futures.as_completed(futures):
+            pass

wandb/cli/cli.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import asyncio
 import configparser
 import datetime
@@ -7,7 +5,6 @@ import getpass
 import json
 import logging
 import os
-import pathlib
 import shlex
 import shutil
 import subprocess
@@ -28,14 +25,11 @@ from dockerpycreds.utils import find_executable
 
 import wandb
 import wandb.env
-
-# from wandb.old.core import wandb_dir
 import wandb.errors
 import wandb.sdk.verify.verify as wandb_verify
 from wandb import Config, Error, env, util, wandb_agent, wandb_sdk
 from wandb.apis import InternalApi, PublicApi
 from wandb.apis.public import RunQueue
-from wandb.errors import UsageError, WandbCoreNotAvailableError
 from wandb.integration.magic import magic_install
 from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
 from wandb.sdk.launch import utils as launch_utils
@@ -46,7 +40,8 @@ from wandb.sdk.launch.sweeps.scheduler import Scheduler
 from wandb.sdk.lib import filesystem
 from wandb.sdk.lib.wburls import wburls
 from wandb.sync import SyncManager, get_run_from_path, get_runs
-from wandb.util import get_core_path
+
+from .beta import beta
 
 # Send cli logs to wandb/debug-cli.<username>.log by default and fallback to a temp dir.
 _wandb_dir = wandb.old.core.wandb_dir(env.get_dir())
@@ -432,170 +427,6 @@ def init(ctx, project, entity, reset, mode):
     )
 
 
-@cli.group()
-def beta():
-    """Beta versions of wandb CLI commands. Requires wandb-core."""
-    # this is the future that requires wandb-core!
-    import wandb.env
-
-    wandb._sentry.configure_scope(process_context="wandb_beta")
-
-    if wandb.env.is_require_legacy_service():
-        raise UsageError(
-            "wandb beta commands can only be used with wandb-core. "
-            f"Please make sure that `{wandb.env._REQUIRE_LEGACY_SERVICE}` is not set."
-        )
-
-    try:
-        get_core_path()
-    except WandbCoreNotAvailableError as e:
-        wandb._sentry.exception(f"using `wandb beta`. failed with {e}")
-        click.secho(
-            (e),
-            fg="red",
-            err=True,
-        )
-
-
-@beta.command(
-    name="sync",
-    context_settings=CONTEXT,
-    help="Upload a training run to W&B",
-)
-@click.pass_context
-@click.argument("wandb_dir", nargs=1, type=click.Path(exists=True))
-@click.option("--id", "run_id", help="The run you want to upload to.")
-@click.option("--project", "-p", help="The project you want to upload to.")
-@click.option("--entity", "-e", help="The entity to scope to.")
-@click.option("--skip-console", is_flag=True, default=False, help="Skip console logs")
-@click.option("--append", is_flag=True, default=False, help="Append run")
-@click.option(
-    "--include",
-    "-i",
-    help="Glob to include. Can be used multiple times.",
-    multiple=True,
-)
-@click.option(
-    "--exclude",
-    "-e",
-    help="Glob to exclude. Can be used multiple times.",
-    multiple=True,
-)
-@click.option(
-    "--mark-synced/--no-mark-synced",
-    is_flag=True,
-    default=True,
-    help="Mark runs as synced",
-)
-@click.option(
-    "--skip-synced/--no-skip-synced",
-    is_flag=True,
-    default=True,
-    help="Skip synced runs",
-)
-@click.option(
-    "--dry-run", is_flag=True, help="Perform a dry run without uploading anything."
-)
-@display_error
-def sync_beta(
-    ctx,
-    wandb_dir=None,
-    run_id: Optional[str] = None,
-    project: Optional[str] = None,
-    entity: Optional[str] = None,
-    skip_console: bool = False,
-    append: bool = False,
-    include: Optional[str] = None,
-    exclude: Optional[str] = None,
-    skip_synced: bool = True,
-    mark_synced: bool = True,
-    dry_run: bool = False,
-):
-    import concurrent.futures
-    from multiprocessing import cpu_count
-
-    paths = set()
-
-    # TODO: test file discovery logic
-    # include and exclude globs are evaluated relative to the provided base_path
-    if include:
-        for pattern in include:
-            matching_dirs = list(pathlib.Path(wandb_dir).glob(pattern))
-            for d in matching_dirs:
-                if not d.is_dir():
-                    continue
-                wandb_files = [p for p in d.glob("*.wandb") if p.is_file()]
-                if len(wandb_files) > 1:
-                    print(f"Multiple wandb files found in directory {d}, skipping")
-                elif len(wandb_files) == 1:
-                    paths.add(d)
-    else:
-        paths.update({p.parent for p in pathlib.Path(wandb_dir).glob("**/*.wandb")})
-
-    for pattern in exclude:
-        matching_dirs = list(pathlib.Path(wandb_dir).glob(pattern))
-        for d in matching_dirs:
-            if not d.is_dir():
-                continue
-            if d in paths:
-                paths.remove(d)
-
-    # remove paths that are already synced, if requested
-    if skip_synced:
-        synced_paths = set()
-        for path in paths:
-            wandb_synced_files = [p for p in path.glob("*.wandb.synced") if p.is_file()]
-            if len(wandb_synced_files) > 1:
-                print(
-                    f"Multiple wandb.synced files found in directory {path}, skipping"
-                )
-            elif len(wandb_synced_files) == 1:
-                synced_paths.add(path)
-        paths -= synced_paths
-
-    if run_id and len(paths) > 1:
-        # TODO: handle this more gracefully
-        click.echo("id can only be set for a single run.", err=True)
-        sys.exit(1)
-
-    if not paths:
-        click.echo("No runs to sync.")
-        return
-
-    click.echo("Found runs:")
-    for path in paths:
-        click.echo(f"  {path}")
-
-    if dry_run:
-        return
-
-    wandb.sdk.wandb_setup.setup()
-
-    # TODO: make it thread-safe in the Rust code
-    with concurrent.futures.ProcessPoolExecutor(
-        max_workers=min(len(paths), cpu_count())
-    ) as executor:
-        futures = []
-        for path in paths:
-            # we already know there is only one wandb file in the directory
-            wandb_file = [p for p in path.glob("*.wandb") if p.is_file()][0]
-            future = executor.submit(
-                wandb._sync,
-                wandb_file,
-                run_id=run_id,
-                project=project,
-                entity=entity,
-                skip_console=skip_console,
-                append=append,
-                mark_synced=mark_synced,
-            )
-            futures.append(future)
-
-        # Wait for tasks to complete
-        for _ in concurrent.futures.as_completed(futures):
-            pass
-
-
 @cli.command(
     context_settings=CONTEXT, help="Upload an offline training directory to W&B"
 )
@@ -3002,3 +2833,6 @@ def verify(host):
         and url_success
     ):
         sys.exit(1)
+
+
+cli.add_command(beta)

wandb/data_types.py

@@ -14,6 +14,7 @@ and upload them to the W&B server.
 """
 
 from .sdk.data_types.audio import Audio
+from .sdk.data_types.base_types.media import BatchableMedia, Media
 from .sdk.data_types.base_types.wb_value import WBValue
 from .sdk.data_types.bokeh import Bokeh
 from .sdk.data_types.graph import Graph, Node
@@ -56,6 +57,8 @@ __all__ = [
     "WBTraceTree",
     "_SavedModel",
     "WBValue",
+    "Media",
+    "BatchableMedia",
     # Typed Legacy Exports (I'd like to remove these)
     "ImageMask",
     "BoundingBoxes2D",