wandb 0.21.1__py3-none-win_amd64.whl → 0.21.2__py3-none-win_amd64.whl

wandb/automations/_generated/enums.py

@@ -6,13 +6,10 @@ from __future__ import annotations
 from enum import Enum
 
 
-class EventTriggeringConditionType(str, Enum):
-    CREATE_ARTIFACT = "CREATE_ARTIFACT"
-    UPDATE_ARTIFACT_ALIAS = "UPDATE_ARTIFACT_ALIAS"
-    ADD_ARTIFACT_ALIAS = "ADD_ARTIFACT_ALIAS"
-    LINK_MODEL = "LINK_MODEL"
-    RUN_METRIC = "RUN_METRIC"
-    RUN_METRIC_CHANGE = "RUN_METRIC_CHANGE"
+class AlertSeverity(str, Enum):
+    INFO = "INFO"
+    WARN = "WARN"
+    ERROR = "ERROR"
 
 
 class TriggerScopeType(str, Enum):
@@ -20,10 +17,15 @@ class TriggerScopeType(str, Enum):
     ARTIFACT_COLLECTION = "ARTIFACT_COLLECTION"
 
 
-class AlertSeverity(str, Enum):
-    INFO = "INFO"
-    WARN = "WARN"
-    ERROR = "ERROR"
+class EventTriggeringConditionType(str, Enum):
+    CREATE_ARTIFACT = "CREATE_ARTIFACT"
+    UPDATE_ARTIFACT_ALIAS = "UPDATE_ARTIFACT_ALIAS"
+    ADD_ARTIFACT_ALIAS = "ADD_ARTIFACT_ALIAS"
+    ADD_ARTIFACT_TAG = "ADD_ARTIFACT_TAG"
+    LINK_MODEL = "LINK_MODEL"
+    RUN_METRIC = "RUN_METRIC"
+    RUN_METRIC_CHANGE = "RUN_METRIC_CHANGE"
+    RUN_STATE = "RUN_STATE"
 
 
 class TriggeredActionType(str, Enum):

wandb/cli/cli.py

@@ -1906,6 +1906,12 @@ def describe(job):
     help="Service configurations in format serviceName=policy. Valid policies: always, never",
     hidden=True,
 )
+@click.option(
+    "--schema",
+    type=str,
+    help="Path to the schema file for the job.",
+    hidden=True,
+)
 @click.argument("path")
 def create(
     path,
@@ -1922,6 +1928,7 @@ def create(
     base_image,
     dockerfile,
     services,
+    schema,
 ):
     """Create a job from a source, without a wandb run.
 
@@ -1956,6 +1963,12 @@ def create(
         wandb.termerror("Cannot provide --base-image/-B for an `image` job")
         return
 
+    if schema:
+        schema_dict = util.load_json_yaml_dict(schema)
+        if schema_dict is None:
+            wandb.termerror(f"Invalid format for schema file: {schema}")
+            return
+
     artifact, action, aliases = _create_job(
         api=api,
         path=path,
@@ -1972,6 +1985,7 @@ def create(
         base_image=base_image,
         dockerfile=dockerfile,
         services=services,
+        schema=schema_dict,
     )
     if not artifact:
         wandb.termerror("Job creation failed")
@@ -2539,7 +2553,8 @@ def pull(run, project, entity):
 
 
 @cli.command(
-    context_settings=CONTEXT, help="Restore code, config and docker state for a run"
+    context_settings=CONTEXT,
+    help="Restore code, config and docker state for a run. Retrieves code from latest commit if code was not saved with `wandb.save()` or `wandb.init(save_code=True)`.",
 )
 @click.pass_context
 @click.argument("run", envvar=env.RUN_ID)
@@ -2779,7 +2794,37 @@ def enabled(service):
         )
 
 
-@cli.command(context_settings=CONTEXT, help="Verify your local instance")
+@cli.command(
+    context_settings=CONTEXT,
+    help="""Checks and verifies local instance of W&B. W&B checks for:
+
+    Checks that the host is not `api.wandb.ai` (host check).
+
+    Verifies if the user is logged in correctly using the provided API key (login check).
+
+    Checks that requests are made over HTTPS (secure requests).
+
+    Validates the CORS (Cross-Origin Resource Sharing) configuration of the
+    object store (CORS configuration).
+
+    Logs metrics, saves, and downloads files to check if runs are correctly
+    recorded and accessible (run check).
+
+    Saves and downloads artifacts to verify that the artifact storage and
+    retrieval system is working as expected (artifact check).
+
+    Tests the GraphQL endpoint by uploading a file to ensure it can handle
+    signed URL uploads (GraphQL PUT check).
+
+    Checks the ability to send large payloads through the proxy (large payload check).
+
+    Verifies that the installed version of the W&B package is up-to-date and
+    compatible with the server (W&B version check).
+
+    Creates and executes a sweep to ensure that sweep functionality is
+    working correctly (sweeps check).
+""",
+)
 @click.option("--host", default=None, help="Test a specific instance of W&B")
 def verify(host):
     # TODO: (kdg) Build this all into a WandbVerify object, and clean this up.

wandb/integration/metaflow/data_pandas.py

@@ -5,7 +5,7 @@ May raise MissingDependencyError on import.
 
 from __future__ import annotations
 
-from typing_extensions import Any, TypeGuard
+from typing_extensions import Any, TypeIs
 
 import wandb
 
@@ -21,7 +21,7 @@ except ImportError as e:
     raise errors.MissingDependencyError(warning=warning) from e
 
 
-def is_dataframe(data: Any) -> TypeGuard[pd.DataFrame]:
+def is_dataframe(data: Any) -> TypeIs[pd.DataFrame]:
     """Returns whether the data is a Pandas DataFrame."""
     return isinstance(data, pd.DataFrame)
 

wandb/integration/metaflow/data_pytorch.py

@@ -0,0 +1,75 @@
+"""Support for PyTorch datatypes.
+
+May raise MissingDependencyError on import.
+"""
+
+from __future__ import annotations
+
+from typing_extensions import Any, TypeIs
+
+import wandb
+
+from . import errors
+
+try:
+    import torch
+    import torch.nn as nn
+except ImportError as e:
+    warning = (
+        "`torch` (PyTorch) not installed >>"
+        " @wandb_log(models=True) may not auto log your model!"
+    )
+    raise errors.MissingDependencyError(warning=warning) from e
+
+
+def is_nn_module(data: Any) -> TypeIs[nn.Module]:
+    """Returns whether the data is a PyTorch nn.Module."""
+    return isinstance(data, nn.Module)
+
+
+def use_nn_module(
+    name: str,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a dependency on a PyTorch model input.
+
+    Args:
+        name: Name of the input.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "models"
+    assert run
+
+    wandb.termlog(f"Using artifact: {name} (PyTorch nn.Module)")
+    run.use_artifact(f"{name}:latest")
+    return None
+
+
+def track_nn_module(
+    name: str,
+    data: nn.Module,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a PyTorch model output as an artifact.
+
+    Args:
+        name: The output's name.
+        data: The output's value.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "nn.Module"
+    assert run
+
+    artifact = wandb.Artifact(name, type="model")
+    with artifact.new_file(f"{name}.pkl", "wb") as f:
+        torch.save(data, f)
+
+    wandb.termlog(f"Logging artifact: {name} (PyTorch nn.Module)")
+    run.log_artifact(artifact)
+    return None

wandb/integration/metaflow/data_sklearn.py

@@ -0,0 +1,76 @@
+"""Support for sklearn datatypes.
+
+May raise MissingDependencyError on import.
+"""
+
+from __future__ import annotations
+
+import pickle
+
+from typing_extensions import Any, TypeIs
+
+import wandb
+
+from . import errors
+
+try:
+    from sklearn.base import BaseEstimator
+except ImportError as e:
+    warning = (
+        "`sklearn` not installed >>"
+        " @wandb_log(models=True) may not auto log your model!"
+    )
+    raise errors.MissingDependencyError(warning=warning) from e
+
+
+def is_estimator(data: Any) -> TypeIs[BaseEstimator]:
+    """Returns whether the data is an sklearn BaseEstimator."""
+    return isinstance(data, BaseEstimator)
+
+
+def use_estimator(
+    name: str,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a dependency on an sklearn estimator.
+
+    Args:
+        name: Name of the input.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "models"
+    assert run
+
+    wandb.termlog(f"Using artifact: {name} (sklearn BaseEstimator)")
+    run.use_artifact(f"{name}:latest")
+    return None
+
+
+def track_estimator(
+    name: str,
+    data: BaseEstimator,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log an sklearn estimator output as an artifact.
+
+    Args:
+        name: The output's name.
+        data: The output's value.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "BaseEstimator"
+    assert run
+
+    artifact = wandb.Artifact(name, type="model")
+    with artifact.new_file(f"{name}.pkl", "wb") as f:
+        pickle.dump(data, f)
+
+    wandb.termlog(f"Logging artifact: {name} (sklearn BaseEstimator)")
+    run.log_artifact(artifact)
+    return None

wandb/integration/metaflow/metaflow.py

@@ -18,10 +18,6 @@ except ImportError as e:
     ) from e
 
 
-# Classes for isinstance() checks.
-_NN_MODULE = None
-_BASE_ESTIMATOR = None
-
 try:
     from . import data_pandas
 except errors.MissingDependencyError as e:
@@ -29,83 +25,16 @@ except errors.MissingDependencyError as e:
     data_pandas = None
 
 try:
-    import torch
-    import torch.nn as nn
-
-    _NN_MODULE = nn.Module
-
-    def _use_torch_module(
-        name: str,
-        data: nn.Module,
-        run,
-        testing: bool = False,
-    ) -> Optional[str]:
-        if testing:
-            return "models"
-
-        run.use_artifact(f"{name}:latest")
-        wandb.termlog(f"Using artifact: {name} ({type(data)})")
-        return None
-
-    def _track_torch_module(
-        name: str,
-        data: nn.Module,
-        run,
-        testing: bool = False,
-    ) -> Optional[str]:
-        if testing:
-            return "nn.Module"
-
-        artifact = wandb.Artifact(name, type="model")
-        with artifact.new_file(f"{name}.pkl", "wb") as f:
-            torch.save(data, f)
-        run.log_artifact(artifact)
-        wandb.termlog(f"Logging artifact: {name} ({type(data)})")
-        return None
-
-except ImportError:
-    wandb.termwarn(
-        "`pytorch` not installed >> @wandb_log(models=True) may not auto log your model!"
-    )
+    from . import data_pytorch
+except errors.MissingDependencyError as e:
+    e.warn()
+    data_pytorch = None
 
 try:
-    from sklearn.base import BaseEstimator
-
-    _BASE_ESTIMATOR = BaseEstimator
-
-    def _use_sklearn_estimator(
-        name: str,
-        data: BaseEstimator,
-        run,
-        testing: bool = False,
-    ) -> Optional[str]:
-        if testing:
-            return "models"
-
-        run.use_artifact(f"{name}:latest")
-        wandb.termlog(f"Using artifact: {name} ({type(data)})")
-        return None
-
-    def _track_sklearn_estimator(
-        name: str,
-        data: BaseEstimator,
-        run,
-        testing: bool = False,
-    ) -> Optional[str]:
-        if testing:
-            return "BaseEstimator"
-
-        artifact = wandb.Artifact(name, type="model")
-        with artifact.new_file(f"{name}.pkl", "wb") as f:
-            pickle.dump(data, f)
-        run.log_artifact(artifact)
-        wandb.termlog(f"Logging artifact: {name} ({type(data)})")
-        return None
-
-except ImportError:
-    wandb.termwarn(
-        "`sklearn` not installed >> @wandb_log(models=True) may not auto log your model!"
-    )
+    from . import data_sklearn
+except errors.MissingDependencyError as e:
+    e.warn()
+    data_sklearn = None
 
 
 class ArtifactProxy:
@@ -195,12 +124,12 @@ def wandb_track(
         return data_pandas.track_dataframe(name, data, run, testing)
 
     # Check for PyTorch Module
-    if _NN_MODULE and isinstance(data, _NN_MODULE) and models:
-        return _track_torch_module(name, data, run, testing)
+    if data_pytorch and data_pytorch.is_nn_module(data) and models:
+        return data_pytorch.track_nn_module(name, data, run, testing)
 
     # Check for scikit-learn BaseEstimator
-    if _BASE_ESTIMATOR and isinstance(data, _BASE_ESTIMATOR) and models:
-        return _track_sklearn_estimator(name, data, run, testing)
+    if data_sklearn and data_sklearn.is_estimator(data) and models:
+        return data_sklearn.track_estimator(name, data, run, testing)
 
     # Check for Path objects
     if isinstance(data, Path) and datasets:
@@ -238,12 +167,12 @@ def wandb_use(
             return data_pandas.use_dataframe(name, run, testing)
 
         # Check for PyTorch Module
-        elif _NN_MODULE and isinstance(data, _NN_MODULE) and models:
-            return _use_torch_module(name, data, run, testing)
+        elif data_pytorch and data_pytorch.is_nn_module(data) and models:
+            return data_pytorch.use_nn_module(name, run, testing)
 
         # Check for scikit-learn BaseEstimator
-        elif _BASE_ESTIMATOR and isinstance(data, _BASE_ESTIMATOR) and models:
-            return _use_sklearn_estimator(name, data, run, testing)
+        elif data_sklearn and data_sklearn.is_estimator(data) and models:
+            return data_sklearn.use_estimator(name, run, testing)
 
         # Check for Path objects
         elif isinstance(data, Path) and datasets:

wandb/integration/weave/__init__.py

@@ -0,0 +1,6 @@
+"""Weave integration for W&B."""
+
+from .interface import RunPath, active_run_path
+from .weave import setup
+
+__all__ = ("active_run_path", "RunPath", "setup")

wandb/integration/weave/interface.py

@@ -0,0 +1,49 @@
+"""Internal APIs for integrating with weave.
+
+The public functions here are intended to be called by weave and care should
+be taken to maintain backward compatibility.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+from wandb.sdk import wandb_setup
+
+
+@dataclasses.dataclass(frozen=True)
+class RunPath:
+    entity: str
+    """The entity to which the run is logging. Never empty."""
+
+    project: str
+    """The project to which the run is logging. Never empty."""
+
+    run_id: str
+    """The run's ID. Never empty."""
+
+
+def active_run_path() -> RunPath | None:
+    """Returns the path of an initialized, unfinished run.
+
+    Returns None if all initialized runs are finished. If there is
+    more than one active run, an arbitrary path is returned.
+    The run may be finished by the time its path is returned.
+
+    Thread-safe.
+    """
+    singleton = wandb_setup.singleton()
+
+    if (
+        (run := singleton.most_recent_active_run)
+        and run.entity
+        and run.project
+        and run.id
+    ):
+        return RunPath(
+            entity=run.entity,
+            project=run.project,
+            run_id=run.id,
+        )
+
+    return None

wandb/integration/weave/weave.py

@@ -0,0 +1,63 @@
+"""Integration module for automatic Weave initialization with W&B.
+
+This module provides automatic initialization of Weave when:
+1. Weave is installed
+2. A W&B run is active with a project
+3. Weave is imported (init-on-import)
+
+The integration can be disabled by setting the WANDB_DISABLE_WEAVE environment variable.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+
+import wandb
+
+_weave_init_lock = threading.Lock()
+
+_DISABLE_WEAVE = "WANDB_DISABLE_WEAVE"
+_WEAVE_PACKAGE_NAME = "weave"
+
+
+def setup(entity: str | None, project: str | None) -> None:
+    """Set up automatic Weave initialization for the current W&B run.
+
+    Args:
+        project: The W&B project name to use for Weave initialization.
+    """
+    # We can't or shouldn't init weave; return
+    if os.getenv(_DISABLE_WEAVE):
+        return
+    if not project:
+        return
+
+    # Use entity/project when available; otherwise fall back to project only
+    if entity:
+        project_path = f"{entity}/{project}"
+    else:
+        project_path = project
+
+    # If weave is not yet imported, we can't init it from here.  Instead, we'll
+    # rely on the weave library itself to detect a run and init itself.
+    if _WEAVE_PACKAGE_NAME not in sys.modules:
+        return
+
+    # If weave has already been imported, initialize immediately
+    with _weave_init_lock:
+        try:
+            # This import should have already happened, so it's effectively a no-op.
+            # We just import to keep the symbol for the init that follows
+            import weave
+        except ImportError:
+            # This should never happen; but we don't raise here to avoid
+            # breaking the wandb run init flow just in case
+            return
+
+        wandb.termlog("Initializing weave.")
+        try:
+            weave.init(project_path)
+        except Exception as e:
+            wandb.termwarn(f"Failed to automatically initialize Weave: {e}")