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

wandb/beta/workflows.py

@@ -1,21 +1,31 @@
+from __future__ import annotations
+
 import json
 import os
-from typing import Any, Dict, List, Optional, Union
+import warnings
+from typing import Any
+
+from typing_extensions import deprecated
 
 import wandb
-import wandb.data_types as data_types
-from wandb.data_types import _SavedModel
+from wandb.data_types import WBValue, _SavedModel
+from wandb.proto.wandb_deprecated import Deprecated
 from wandb.sdk import wandb_setup
 from wandb.sdk.artifacts.artifact import Artifact
 from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+from wandb.sdk.lib.deprecate import deprecate as wandb_deprecate
+
+warnings.warn(
+    message=f"The {__name__!r} module is deprecated and will be removed in a future version. Please use the equivalent 'wandb.Run' methods instead.",
+    category=DeprecationWarning,
+    stacklevel=2,
+)
 
 
 def _add_any(
     artifact: Artifact,
-    path_or_obj: Union[
-        str, ArtifactManifestEntry, data_types.WBValue
-    ],  # todo: add dataframe
-    name: Optional[str],
+    path_or_obj: str | ArtifactManifestEntry | WBValue,  # todo: add dataframe
+    name: str | None,
 ) -> Any:
     """Add an object to an artifact.
 
@@ -24,11 +34,10 @@ def _add_any(
     be moved to the Artifact class in the future.
 
     Args:
-        artifact: `Artifact` - artifact created with `wandb.Artifact(...)`
-        path_or_obj: `Union[str, ArtifactManifestEntry, data_types.WBValue]` - either a
-            str or valid object which indicates what to add to an artifact.
-
-        name: `str` - the name of the object which is added to an artifact.
+        artifact: artifact created with `wandb.Artifact(...)`
+        path_or_obj: either a str or valid object which indicates what to add
+            to an artifact.
+        name: the name of the object which is added to an artifact.
 
     Returns:
         Type[Any] - Union[None, ArtifactManifestEntry, etc]
@@ -36,7 +45,7 @@ def _add_any(
     """
     if isinstance(path_or_obj, ArtifactManifestEntry):
         return artifact.add_reference(path_or_obj, name)
-    elif isinstance(path_or_obj, data_types.WBValue):
+    elif isinstance(path_or_obj, WBValue):
         return artifact.add(path_or_obj, name)
     elif isinstance(path_or_obj, str):
         if os.path.isdir(path_or_obj):
@@ -56,12 +65,12 @@ def _add_any(
 def _log_artifact_version(
     name: str,
     type: str,
-    entries: Dict[str, Union[str, ArtifactManifestEntry, data_types.WBValue]],
-    aliases: Optional[Union[str, List[str]]] = None,
-    description: Optional[str] = None,
-    metadata: Optional[dict] = None,
-    project: Optional[str] = None,
-    scope_project: Optional[bool] = None,
+    entries: dict[str, str | ArtifactManifestEntry | WBValue],
+    aliases: str | list[str] | None = None,
+    description: str | None = None,
+    metadata: dict | None = None,
+    project: str | None = None,
+    scope_project: bool | None = None,
     job_type: str = "auto",
 ) -> Artifact:
     """Create an artifact, populate it, and log it with a run.
@@ -113,16 +122,20 @@ def _log_artifact_version(
     return art
 
 
+_LOG_MODEL_DEPRECATION_MSG = "`log_model` is deprecated and will be removed in a future version. Please use `Run.log_artifact` instead."
+
+
+@deprecated(_LOG_MODEL_DEPRECATION_MSG)
 def log_model(
     model_obj: Any,
     name: str = "model",
-    aliases: Optional[Union[str, List[str]]] = None,
-    description: Optional[str] = None,
-    metadata: Optional[dict] = None,
-    project: Optional[str] = None,
-    scope_project: Optional[bool] = None,
-    **kwargs: Dict[str, Any],
-) -> "_SavedModel":
+    aliases: str | list[str] | None = None,
+    description: str | None = None,
+    metadata: dict | None = None,
+    project: str | None = None,
+    scope_project: bool | None = None,
+    **kwargs: dict[str, Any],
+) -> _SavedModel:
     """Log a model object to enable model-centric workflows in the UI.
 
     Supported frameworks include PyTorch, Keras, Tensorflow, Scikit-learn, etc. Under
@@ -168,7 +181,12 @@ def log_model(
         ```
 
     """
-    model = data_types._SavedModel.init(model_obj, **kwargs)
+    wandb_deprecate(
+        field_name=Deprecated.beta__workflows__log_model,
+        warning_message=_LOG_MODEL_DEPRECATION_MSG,
+    )
+
+    model = _SavedModel.init(model_obj, **kwargs)
     _ = _log_artifact_version(
         name=name,
         type="model",
@@ -186,7 +204,11 @@ def log_model(
     return model
 
 
-def use_model(aliased_path: str, unsafe: bool = False) -> "_SavedModel":
+_USE_MODEL_DEPRECATION_MSG = "`use_model` is deprecated and will be removed in a future version. Please update your code to use `Run.use_artifact` instead."
+
+
+@deprecated(_USE_MODEL_DEPRECATION_MSG)
+def use_model(aliased_path: str, unsafe: bool = False) -> _SavedModel:
     """Fetch a saved model from an alias.
 
     Under the hood, we use the alias to fetch the model artifact containing the
@@ -209,6 +231,11 @@ def use_model(aliased_path: str, unsafe: bool = False) -> "_SavedModel":
         model = sm.model_obj()
         ```
     """
+    wandb_deprecate(
+        field_name=Deprecated.beta__workflows__use_model,
+        warning_message=_USE_MODEL_DEPRECATION_MSG,
+    )
+
     if not unsafe:
         raise ValueError("The 'unsafe' parameter must be set to True to load a model.")
 
@@ -234,10 +261,14 @@ def use_model(aliased_path: str, unsafe: bool = False) -> "_SavedModel":
         )
 
 
+_LINK_MODEL_DEPRECATION_MSG = "`link_model` is deprecated and will be removed in a future version. Please use `Run.link_artifact` instead."
+
+
+@deprecated(_LINK_MODEL_DEPRECATION_MSG)
 def link_model(
-    model: "_SavedModel",
+    model: _SavedModel,
     target_path: str,
-    aliases: Optional[Union[str, List[str]]] = None,
+    aliases: str | list[str] | None = None,
 ) -> None:
     """Link the given model to a portfolio.
 
@@ -261,6 +292,11 @@ def link_model(
         link_model(sm, "my-portfolio")
 
     """
+    wandb_deprecate(
+        field_name=Deprecated.beta__workflows__link_model,
+        warning_message=_LINK_MODEL_DEPRECATION_MSG,
+    )
+
     aliases = wandb.util._resolve_aliases(aliases)
 
     if run := wandb_setup.singleton().most_recent_active_run:

wandb/cli/cli.py

@@ -14,7 +14,7 @@ import textwrap
 import time
 import traceback
 from functools import wraps
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 import click
 import yaml
@@ -95,6 +95,39 @@ class ClickWandbException(ClickException):
             )
 
 
+def parse_service_config(
+    ctx: Optional[click.Context],
+    param: Optional[click.Parameter],
+    value: Optional[Tuple[str, ...]],
+) -> Dict[str, str]:
+    """Parse service configurations in format serviceName=policy."""
+    if not value:
+        return {}
+
+    result = {}
+    for config in value:
+        if "=" not in config:
+            raise click.BadParameter(
+                f"Service must be in format 'serviceName=policy', got '{config}'"
+            )
+
+        service_name, policy = config.split("=", 1)
+        service_name = service_name.strip()
+        policy = policy.strip()
+        if not service_name:
+            raise click.BadParameter("Service name cannot be empty")
+
+        # Simple validation for two policies
+        if policy not in ["always", "never"]:
+            raise click.BadParameter(
+                f"Policy must be 'always' or 'never', got '{policy}'"
+            )
+
+        result[service_name] = policy
+
+    return result
+
+
 def display_error(func):
     """Function decorator for catching common errors and re-raising as wandb.Error."""
 
@@ -454,6 +487,10 @@ def init(ctx, project, entity, reset, mode):
 @click.option("--show", default=5, help="Number of runs to show")
 @click.option("--append", is_flag=True, default=False, help="Append run")
 @click.option("--skip-console", is_flag=True, default=False, help="Skip console logs")
+@click.option(
+    "--replace-tags",
+    help="Replace tags in the format 'old_tag1=new_tag1,old_tag2=new_tag2'",
+)
 @display_error
 def sync(
     ctx,
@@ -479,6 +516,7 @@ def sync(
     clean_force=None,
     append=None,
     skip_console=None,
+    replace_tags=None,
 ):
     api = _get_cling_api()
     if not api.is_authenticated:
@@ -493,6 +531,10 @@ def sync(
     if exclude_globs:
         exclude_globs = exclude_globs.split(",")
 
+    replace_tags_dict = _parse_sync_replace_tags(replace_tags)
+    if replace_tags and replace_tags_dict is None:
+        return  # Error already printed by helper function
+
     def _summary():
         all_items = get_runs(
             include_online=True,
@@ -548,6 +590,7 @@ def sync(
             log_path=_wandb_log_path,
             append=append,
             skip_console=skip_console,
+            replace_tags=replace_tags_dict,
         )
         for p in _path:
             sm.add(p)
@@ -633,6 +676,31 @@ def sync(
         _summary()
 
 
+def _parse_sync_replace_tags(replace_tags: str) -> Optional[Dict[str, str]]:
+    """Parse replace_tags string into a dictionary.
+
+    Args:
+        replace_tags: String in format 'old_tag1=new_tag1,old_tag2=new_tag2'
+
+    Returns:
+        Mapping of old tags to new tags, or None if format is invalid
+    """
+    if not replace_tags:
+        return {}
+
+    replace_tags_dict = {}
+    for pair in replace_tags.split(","):
+        if "=" not in pair:
+            wandb.termerror(
+                f"Invalid replace-tags format: {pair}. Use 'old_tag=new_tag' format."
+            )
+            return None
+        old_tag, new_tag = pair.split("=", 1)
+        replace_tags_dict[old_tag.strip()] = new_tag.strip()
+
+    return replace_tags_dict
+
+
 @cli.command(
     context_settings=CONTEXT,
     help="Initialize a hyperparameter sweep. Search for hyperparameters that optimizes a cost function of a machine learning model by testing various combinations.",
@@ -1829,6 +1897,21 @@ def describe(job):
     "job_type",
     type=click.Choice(("git", "code", "image")),
 )
+@click.option(
+    "--service",
+    "-s",
+    "services",
+    multiple=True,
+    callback=parse_service_config,
+    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,
@@ -1844,6 +1927,8 @@ def create(
     build_context,
     base_image,
     dockerfile,
+    services,
+    schema,
 ):
     """Create a job from a source, without a wandb run.
 
@@ -1878,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,
@@ -1893,6 +1984,8 @@ def create(
         build_context=build_context,
         base_image=base_image,
         dockerfile=dockerfile,
+        services=services,
+        schema=schema_dict,
     )
     if not artifact:
         wandb.termerror("Job creation failed")
@@ -2460,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)
@@ -2700,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/env.py

@@ -159,6 +159,14 @@ def is_offline(env: MutableMapping | None = None) -> bool:
     return env.get(MODE) == "offline"
 
 
+def is_quiet() -> bool:
+    return _env_as_bool(QUIET, default="false")
+
+
+def is_silent() -> bool:
+    return _env_as_bool(SILENT, default="false")
+
+
 def error_reporting_enabled() -> bool:
     return _env_as_bool(ERROR_REPORTING, default="True")
 

wandb/errors/errors.py

@@ -2,7 +2,10 @@ from typing import Optional
 
 
 class Error(Exception):
-    """Base W&B Error."""
+    """Base W&B Error.
+
+    <!-- lazydoc-ignore-class: internal -->
+    """
 
     def __init__(self, message, context: Optional[dict] = None) -> None:
         super().__init__(message)

wandb/integration/lightning/fabric/logger.py

@@ -9,7 +9,6 @@ from typing_extensions import override
 import wandb
 from wandb import Artifact
 from wandb.sdk.lib import telemetry
-from wandb.sdk.wandb_run import Run
 
 try:
     import lightning
@@ -295,7 +294,7 @@ class WandbLogger(Logger):
         anonymous: Optional[bool] = None,
         project: Optional[str] = None,
         log_model: Union[Literal["all"], bool] = False,
-        experiment: Optional["Run"] = None,
+        experiment: Optional["wandb.Run"] = None,
         prefix: str = "",
         checkpoint_name: Optional[str] = None,
         log_checkpoint_on: Union[Literal["success"], Literal["all"]] = "success",
@@ -362,7 +361,7 @@ class WandbLogger(Logger):
 
     @property
     @rank_zero_experiment
-    def experiment(self) -> "Run":
+    def experiment(self) -> "wandb.Run":
         r"""Actual wandb object.
 
         To use wandb features in your :class:`~lightning.pytorch.core.LightningModule`, do the
@@ -395,7 +394,7 @@ class WandbLogger(Logger):
                 self._experiment = wandb.init(**self._wandb_init)
 
                 # define default x-axis
-                if isinstance(self._experiment, Run) and getattr(
+                if isinstance(self._experiment, wandb.Run) and getattr(
                     self._experiment, "define_metric", None
                 ):
                     self._experiment.define_metric("trainer/global_step")

wandb/integration/metaflow/__init__.py

@@ -1,3 +1,9 @@
+"""W&B Integration for Metaflow.
+
+Defines a custom step and flow decorator `wandb_log` that automatically logs
+flow parameters and artifacts to W&B.
+"""
+
 from .metaflow import wandb_log, wandb_track, wandb_use
 
 __all__ = ["wandb_log", "wandb_track", "wandb_use"]

wandb/integration/metaflow/data_pandas.py

@@ -0,0 +1,74 @@
+"""Support for Pandas datatypes.
+
+May raise MissingDependencyError on import.
+"""
+
+from __future__ import annotations
+
+from typing_extensions import Any, TypeIs
+
+import wandb
+
+from . import errors
+
+try:
+    import pandas as pd
+except ImportError as e:
+    warning = (
+        "`pandas` not installed >>"
+        " @wandb_log(datasets=True) may not auto log your dataset!"
+    )
+    raise errors.MissingDependencyError(warning=warning) from e
+
+
+def is_dataframe(data: Any) -> TypeIs[pd.DataFrame]:
+    """Returns whether the data is a Pandas DataFrame."""
+    return isinstance(data, pd.DataFrame)
+
+
+def use_dataframe(
+    name: str,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a dependency on a DataFrame input.
+
+    Args:
+        name: Name of the input.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "datasets"
+    assert run
+
+    wandb.termlog(f"Using artifact: {name} (Pandas DataFrame)")
+    run.use_artifact(f"{name}:latest")
+    return None
+
+
+def track_dataframe(
+    name: str,
+    data: pd.DataFrame,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a DataFrame 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 "pd.DataFrame"
+    assert run
+
+    artifact = wandb.Artifact(name, type="dataset")
+    with artifact.new_file(f"{name}.parquet", "wb") as f:
+        data.to_parquet(f, engine="pyarrow")
+
+    wandb.termlog(f"Logging artifact: {name} (Pandas DataFrame)")
+    run.log_artifact(artifact)
+    return None

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