wandb 0.19.9__py3-none-musllinux_1_2_aarch64.whl → 0.19.11__py3-none-musllinux_1_2_aarch64.whl

wandb/sdk/data_types/video.py

@@ -1,11 +1,12 @@
+import functools
 import logging
 import os
 from io import BytesIO
-from typing import TYPE_CHECKING, Any, Dict, Optional, Sequence, Type, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, Sequence, Type, Union
 
 import wandb
 from wandb import util
-from wandb.sdk.lib import filesystem, runid
+from wandb.sdk.lib import filesystem, printer, printer_asyncio, runid
 
 from . import _dtypes
 from ._private import MEDIA_TMP
@@ -47,36 +48,7 @@ def write_gif_with_image_io(
 
 
 class Video(BatchableMedia):
-    """Format a video for logging to W&B.
-
-    Args:
-        data_or_path: (numpy array, string, io)
-            Video can be initialized with a path to a file or an io object.
-            The format must be "gif", "mp4", "webm" or "ogg".
-            The format must be specified with the format argument.
-            Video can be initialized with a numpy tensor.
-            The numpy tensor must be either 4 dimensional or 5 dimensional.
-            Channels should be (time, channel, height, width) or
-            (batch, time, channel, height width)
-        caption: (string) caption associated with the video for display
-        fps: (int)
-            The frame rate to use when encoding raw video frames. Default value is 4.
-            This parameter has no effect when data_or_path is a string, or bytes.
-        format: (string) format of video, necessary if initializing with path or io object.
-
-    Examples:
-        ### Log a numpy array as a video
-        <!--yeadoc-test:log-video-numpy-->
-        ```python
-        import numpy as np
-        import wandb
-
-        run = wandb.init()
-        # axes are (time, channel, height, width)
-        frames = np.random.randint(low=0, high=256, size=(10, 3, 100, 100), dtype=np.uint8)
-        run.log({"video": wandb.Video(frames, fps=4)})
-        ```
-    """
+    """A class for logging videos to W&B."""
 
     _log_type = "video-file"
     EXTS = ("gif", "mp4", "webm", "ogg")
@@ -88,10 +60,53 @@ class Video(BatchableMedia):
         data_or_path: Union["np.ndarray", str, "TextIO", "BytesIO"],
         caption: Optional[str] = None,
         fps: Optional[int] = None,
-        format: Optional[str] = None,
+        format: Optional[Literal["gif", "mp4", "webm", "ogg"]] = None,
     ):
+        """Initialize a W&B Video object.
+
+        Args:
+            data_or_path:
+                Video can be initialized with a path to a file or an io object.
+                Video can be initialized with a numpy tensor.
+                The numpy tensor must be either 4 dimensional or 5 dimensional.
+                The dimensions should be (number of frames, channel, height, width) or
+                (batch, number of frames, channel, height, width)
+                The format parameter must be specified with the format argument
+                when initializing with a numpy array
+                or io object.
+            caption: Caption associated with the video for display.
+            fps:
+                The frame rate to use when encoding raw video frames.
+                Default value is 4.
+                This parameter has no effect when data_or_path is a string, or bytes.
+            format:
+                Format of video, necessary if initializing with a numpy array
+                or io object. This parameter will be used to determine the format
+                to use when encoding the video data. Accepted values are "gif",
+                "mp4", "webm", or "ogg".
+
+        Examples:
+            ### Log a numpy array as a video
+            ```python
+            import numpy as np
+            import wandb
+
+            with wandb.init() as run:
+                # axes are (number of frames, channel, height, width)
+                frames = np.random.randint(
+                    low=0, high=256, size=(10, 3, 100, 100), dtype=np.uint8
+                )
+                run.log({"video": wandb.Video(frames, format="mp4", fps=4)})
+            ```
+        """
         super().__init__(caption=caption)
 
+        if format is None:
+            wandb.termwarn(
+                "`format` argument was not provided, defaulting to `gif`. "
+                "This parameter will be required in v0.20.0, "
+                "please specify the format explicitly."
+            )
         self._format = format or "gif"
         self._width = None
         self._height = None
@@ -134,7 +149,11 @@ class Video(BatchableMedia):
                     "wandb.Video accepts a file path or numpy like data as input"
                 )
             fps = fps or 4
-            self.encode(fps=fps)
+            printer_asyncio.run_async_with_spinner(
+                printer.new_printer(),
+                "Encoding video...",
+                functools.partial(self.encode, fps=fps),
+            )
 
     def encode(self, fps: int = 4) -> None:
         # import ImageSequenceClip from the appropriate MoviePy module
@@ -152,29 +171,12 @@ class Video(BatchableMedia):
         filename = os.path.join(
             MEDIA_TMP.name, runid.generate_id() + "." + self._format
         )
-        if TYPE_CHECKING:
-            kwargs: Dict[str, Optional[bool]] = {}
-        try:  # older versions of moviepy do not support logger argument
-            kwargs = {"logger": None}
-            if self._format == "gif":
-                write_gif_with_image_io(clip, filename)
-            else:
-                clip.write_videofile(filename, **kwargs)
-        except TypeError:
-            try:  # even older versions of moviepy do not support progress_bar argument
-                kwargs = {"verbose": False, "progress_bar": False}
-                if self._format == "gif":
-                    clip.write_gif(filename, **kwargs)
-                else:
-                    clip.write_videofile(filename, **kwargs)
-            except TypeError:
-                kwargs = {
-                    "verbose": False,
-                }
-                if self._format == "gif":
-                    clip.write_gif(filename, **kwargs)
-                else:
-                    clip.write_videofile(filename, **kwargs)
+
+        if self._format == "gif":
+            write_gif_with_image_io(clip, filename)
+        else:
+            clip.write_videofile(filename, logger=None)
+
         self._set_file(filename, is_tmp=True)
 
     @classmethod

wandb/sdk/interface/interface.py

@@ -173,6 +173,8 @@ class InterfaceBase:
             self._make_config(data=config_dict, obj=proto_run.config)
         if run._telemetry_obj:
             proto_run.telemetry.MergeFrom(run._telemetry_obj)
+        if run._start_runtime:
+            proto_run.runtime = run._start_runtime
         return proto_run
 
     def publish_run(self, run: "Run") -> None:
@@ -426,7 +428,6 @@ class InterfaceBase:
 
     def deliver_link_artifact(
         self,
-        run: "Run",
         artifact: "Artifact",
         portfolio_name: str,
         aliases: Iterable[str],
@@ -440,9 +441,9 @@ class InterfaceBase:
         else:
             link_artifact.server_id = artifact.id if artifact.id else ""
         link_artifact.portfolio_name = portfolio_name
-        link_artifact.portfolio_entity = entity or run.entity
+        link_artifact.portfolio_entity = entity or ""
         link_artifact.portfolio_organization = organization or ""
-        link_artifact.portfolio_project = project or run.project
+        link_artifact.portfolio_project = project or ""
         link_artifact.portfolio_aliases.extend(aliases)
 
         return self._deliver_link_artifact(link_artifact)

wandb/sdk/internal/internal_api.py

@@ -12,6 +12,7 @@ import sys
 import threading
 from copy import deepcopy
 from pathlib import Path
+from types import MappingProxyType
 from typing import (
     IO,
     TYPE_CHECKING,
@@ -189,11 +190,6 @@ def _match_org_with_fetched_org_entities(
     """
     for org_names in orgs:
         if organization in org_names:
-            wandb.termwarn(
-                "Registries can be linked/fetched using a shorthand form without specifying the organization name. "
-                "Try using shorthand path format: <my_registry_name>/<artifact_name> or "
-                "just <my_registry_name> if fetching just the project."
-            )
             return org_names.entity_name
 
     if len(orgs) == 1:
@@ -873,30 +869,29 @@ class Api:
         _, _, mutations = self.server_info_introspection()
         return "updateRunQueueItemWarning" in mutations
 
-    def _check_server_feature(self, feature_value: ServerFeature) -> bool:
-        """Check if a server feature is enabled.
-
-        Args:
-            feature_value (ServerFeature): The enum value of the feature to check.
-
-        Returns:
-            bool: True if the feature is enabled, False otherwise.
-
-        Raises:
-            Exception: If server doesn't support feature queries or other errors occur
-        """
+    def _server_features(self) -> Mapping[str, bool]:
+        """Returns a cached, read-only lookup of current server feature flags."""
         if self._server_features_cache is None:
             query = gql(SERVER_FEATURES_QUERY_GQL)
-            response = self.gql(query)
-            server_info = ServerFeaturesQuery.model_validate(response).server_info
-            if server_info and (features := server_info.features):
-                self._server_features_cache = {
-                    f.name: f.is_enabled for f in features if f
-                }
+
+            try:
+                response = self.gql(query)
+            except Exception as e:
+                # Unfortunately we currently have to match on the text of the error message
+                if 'Cannot query field "features" on type "ServerInfo".' in str(e):
+                    self._server_features_cache = {}
+                else:
+                    raise
             else:
-                self._server_features_cache = {}
+                info = ServerFeaturesQuery.model_validate(response).server_info
+                if info and (feats := info.features):
+                    self._server_features_cache = {
+                        f.name: f.is_enabled for f in feats if f
+                    }
+                else:
+                    self._server_features_cache = {}
 
-        return self._server_features_cache.get(ServerFeature.Name(feature_value), False)
+        return MappingProxyType(self._server_features_cache)
 
     def _check_server_feature_with_fallback(self, feature_value: ServerFeature) -> bool:
         """Wrapper around check_server_feature that warns and returns False for older unsupported servers.
@@ -912,12 +907,7 @@ class Api:
         Exceptions:
             Exception: If an error other than the server not supporting feature queries occurs.
         """
-        try:
-            return self._check_server_feature(feature_value)
-        except Exception as e:
-            if 'Cannot query field "features" on type "ServerInfo".' in str(e):
-                return False
-            raise e
+        return self._server_features().get(ServerFeature.Name(feature_value), False)
 
     @normalize_exceptions
     def update_run_queue_item_warning(

wandb/sdk/internal/profiler.py

@@ -18,12 +18,13 @@ def torch_trace_handler():
      torch.profiler.profile(..., on_trace_ready=wandb.profiler.torch_trace_handler())
      ```
 
-    Calling this function ensures that profiler charts & tables can be viewed in your run dashboard
-    on wandb.ai.
+    Calling this function ensures that profiler charts & tables can be viewed in
+    your run dashboard on wandb.ai.
 
-    Please note that `wandb.init()` must be called before this function is invoked.
-    The PyTorch (torch) version must also be at least 1.9, in order to ensure stability
-    of their Profiler API.
+    Please note that `wandb.init()` must be called before this function is
+    invoked, and the reinit setting must not be set to "create_new". The PyTorch
+    (torch) version must also be at least 1.9, in order to ensure stability of
+    their Profiler API.
 
     Args:
         None

wandb/sdk/internal/run.py

@@ -5,21 +5,28 @@ Semi-stubbed run for internal process use.
 
 """
 
-from wandb._globals import _datatypes_set_callback
+import sys
 
-from .. import wandb_run
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+from wandb.sdk import wandb_run
 
 
 class InternalRun(wandb_run.Run):
     def __init__(self, run_obj, settings, datatypes_cb):
         super().__init__(settings=settings)
         self._run_obj = run_obj
+        self._datatypes_cb = datatypes_cb
 
-        # TODO: This overwrites what's done in the constructor of wandb_run.Run.
-        # We really want a common interface for wandb_run.Run and InternalRun.
-        _datatypes_set_callback(datatypes_cb)
-
+    @override
     def _set_backend(self, backend):
         # This type of run object can't have a backend
         # or do any writes.
         pass
+
+    @override
+    def _publish_file(self, fname: str) -> None:
+        self._datatypes_cb(fname)

wandb/sdk/internal/sender.py

@@ -1444,7 +1444,7 @@ class SendManager:
         )
         if (client_id or server_id) and portfolio_name and entity and project:
             try:
-                self._api.link_artifact(
+                response = self._api.link_artifact(
                     client_id,
                     server_id,
                     portfolio_name,
@@ -1453,9 +1453,12 @@ class SendManager:
                     aliases,
                     organization,
                 )
+                result.response.link_artifact_response.version_index = response[
+                    "versionIndex"
+                ]
             except Exception as e:
                 org_or_entity = organization or entity
-                result.response.log_artifact_response.error_message = (
+                result.response.link_artifact_response.error_message = (
                     f"error linking artifact to "
                     f'"{org_or_entity}/{project}/{portfolio_name}"; error: {e}'
                 )

wandb/sdk/launch/sweeps/utils.py

@@ -223,6 +223,10 @@ def create_sweep_command_args(command: Dict) -> Dict[str, Any]:
     flags_dict: Dict[str, Any] = {}
     # (5) flags without equals (e.g. --foo bar)
     args_no_equals: List[str] = []
+    # (6) flags for hydra append config value (e.g. +foo=bar)
+    flags_append_hydra: List[str] = []
+    # (7) flags for hydra override config value (e.g. ++foo=bar)
+    flags_override_hydra: List[str] = []
     for param, config in command["args"].items():
         # allow 'None' as a valid value, but error if no value is found
         try:
@@ -234,6 +238,8 @@ def create_sweep_command_args(command: Dict) -> Dict[str, Any]:
         flags.append("--" + _flag)
         flags_no_hyphens.append(_flag)
         args_no_equals += [f"--{param}", str(_value)]
+        flags_append_hydra.append("+" + _flag)
+        flags_override_hydra.append("++" + _flag)
         if isinstance(_value, bool):
             # omit flags if they are boolean and false
             if _value:
@@ -248,6 +254,8 @@ def create_sweep_command_args(command: Dict) -> Dict[str, Any]:
         "args_no_boolean_flags": flags_no_booleans,
         "args_json": [json.dumps(flags_dict)],
         "args_dict": flags_dict,
+        "args_append_hydra": flags_append_hydra,
+        "args_override_hydra": flags_override_hydra,
     }
 
 

wandb/sdk/lib/apikey.py

@@ -83,6 +83,25 @@ def get_netrc_file_path() -> str:
     return os.path.join(os.path.expanduser("~"), netrc_file)
 
 
+def _api_key_prompt_str(app_url: str, referrer: str | None = None) -> str:
+    """Generate a prompt string for API key authorization.
+
+    Creates a URL string that directs users to the authorization page where they
+    can find their API key.
+
+    Args:
+        app_url: The base URL of the W&B application.
+        referrer: Optional referrer parameter to include in the URL.
+
+    Returns:
+        A formatted string with instructions and the authorization URL.
+    """
+    ref = ""
+    if referrer:
+        ref = f"?ref={referrer}"
+    return f"You can find your API key in your browser here: {app_url}/authorize{ref}"
+
+
 def prompt_api_key(  # noqa: C901
     settings: Settings,
     api: InternalApi | None = None,
@@ -91,6 +110,7 @@ def prompt_api_key(  # noqa: C901
     no_offline: bool = False,
     no_create: bool = False,
     local: bool = False,
+    referrer: str | None = None,
 ) -> str | bool | None:
     """Prompt for api key.
 
@@ -149,7 +169,10 @@ def prompt_api_key(  # noqa: C901
         key = browser_callback(signup=True) if browser_callback else None
 
         if not key:
-            wandb.termlog(f"Create an account here: {app_url}/authorize?signup=true")
+            ref = f"&ref={referrer}" if referrer else ""
+            wandb.termlog(
+                f"Create an account here: {app_url}/authorize?signup=true{ref}"
+            )
             key = input_callback(api_ask).strip()
     elif result == LOGIN_CHOICE_EXISTS:
         key = browser_callback() if browser_callback else None
@@ -164,9 +187,7 @@ def prompt_api_key(  # noqa: C901
                     f"Logging into {host}. (Learn how to deploy a W&B server "
                     f"locally: {url_registry.url('wandb-server')})"
                 )
-            wandb.termlog(
-                f"You can find your API key in your browser here: {app_url}/authorize"
-            )
+            wandb.termlog(_api_key_prompt_str(app_url, referrer))
             key = input_callback(api_ask).strip()
     elif result == LOGIN_CHOICE_NOTTY:
         # TODO: Needs refactor as this needs to be handled by caller

wandb/sdk/lib/asyncio_compat.py

@@ -53,7 +53,7 @@ class _Runner:
     """
 
     def __init__(self) -> None:
-        self._lock = threading.Condition()
+        self._lock = threading.Lock()
 
         self._is_cancelled = False
         self._started = False

wandb/sdk/lib/deprecate.py

@@ -1,42 +1,33 @@
-__all__ = ["deprecate", "Deprecated"]
+from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional, Tuple
+from typing import TYPE_CHECKING
 
 import wandb
-from wandb.proto.wandb_deprecated import DEPRECATED_FEATURES, Deprecated
-from wandb.proto.wandb_telemetry_pb2 import Deprecated as TelemetryDeprecated
+from wandb.proto.wandb_deprecated import DEPRECATED_FEATURES
+from wandb.sdk.lib import telemetry
 
-# avoid cycle, use string type reference
+# Necessary to break import cycle.
 if TYPE_CHECKING:
-    from .. import wandb_run
-
-
-deprecated_field_names: Tuple[str, ...] = tuple(
-    str(v) for k, v in Deprecated.__dict__.items() if not k.startswith("_")
-)
+    from wandb import wandb_run
 
 
 def deprecate(
     field_name: DEPRECATED_FEATURES,
     warning_message: str,
-    run: Optional["wandb_run.Run"] = None,
+    run: wandb_run.Run | None = None,
 ) -> None:
     """Warn the user that a feature has been deprecated.
 
-    Also stores the information about the event in telemetry.
+    If a run is provided, the given field on its telemetry is updated.
+    Otherwise, the global run is used.
 
     Args:
-        field_name: The name of the feature that has been deprecated.
-                    Defined in wandb/proto/wandb_telemetry.proto::Deprecated
+        field_name: The field on the Deprecated proto for this deprecation.
         warning_message: The message to display to the user.
-        run: The run to whose telemetry the event will be added.
+        run: The run whose telemetry to update.
     """
-    known_fields = TelemetryDeprecated.DESCRIPTOR.fields_by_name.keys()
-    if field_name not in known_fields:
-        raise ValueError(
-            f"Unknown field name: {field_name}. Known fields: {known_fields}"
-        )
     _run = run or wandb.run
-    with wandb.wandb_lib.telemetry.context(run=_run) as tel:  # type: ignore[attr-defined]
+    with telemetry.context(run=_run) as tel:
         setattr(tel.deprecated, field_name, True)
+
     wandb.termwarn(warning_message, repeat=False)

wandb/sdk/lib/disabled.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+from wandb.proto.wandb_deprecated import Deprecated
 from wandb.sdk.lib import deprecate
 
 
@@ -23,7 +24,7 @@ class RunDisabled:
 
     def __getattr__(self, name: str) -> Any:
         deprecate.deprecate(
-            field_name=deprecate.Deprecated.run_disabled,
+            field_name=Deprecated.run_disabled,
             warning_message="RunDisabled is deprecated and is a no-op. "
             '`wandb.init(mode="disabled")` now returns and instance of `wandb.sdk.wandb_run.Run`.',
         )

wandb/sdk/lib/printer.py

@@ -20,6 +20,7 @@ import click
 
 import wandb
 from wandb.errors import term
+from wandb.sdk import wandb_setup
 
 from . import ipython, sparkline
 
@@ -98,12 +99,21 @@ _JUPYTER_PANEL_STYLES = """
 """
 
 
-def new_printer() -> Printer:
-    """Returns a new printer based on the environment we're in."""
+def new_printer(settings: wandb.Settings | None = None) -> Printer:
+    """Returns a printer appropriate for the environment we're in.
+
+    Args:
+        settings: The settings of a run. If not provided and `wandb.setup()`
+            has been called, then global settings are used. Otherwise,
+            settings (such as silent mode) are ignored.
+    """
+    if not settings and (singleton := wandb_setup.singleton()):
+        settings = singleton.settings
+
     if ipython.in_jupyter():
-        return _PrinterJupyter()
+        return _PrinterJupyter(settings=settings)
     else:
-        return _PrinterTerm()
+        return _PrinterTerm(settings=settings)
 
 
 class Printer(abc.ABC):
@@ -281,13 +291,18 @@ class DynamicText(abc.ABC):
 
 
 class _PrinterTerm(Printer):
-    def __init__(self) -> None:
+    def __init__(self, *, settings: wandb.Settings | None) -> None:
         super().__init__()
+        self._settings = settings
         self._progress = itertools.cycle(["-", "\\", "|", "/"])
 
     @override
     @contextlib.contextmanager
     def dynamic_text(self) -> Iterator[DynamicText | None]:
+        if self._settings and self._settings.silent:
+            yield None
+            return
+
         with term.dynamic_text() as handle:
             if not handle:
                 yield None
@@ -301,6 +316,9 @@ class _PrinterTerm(Printer):
         *,
         level: str | int | None = None,
     ) -> None:
+        if self._settings and self._settings.silent:
+            return
+
         text = "\n".join(text) if isinstance(text, (list, tuple)) else text
         self._display_fn_mapping(level)(text)
 
@@ -323,10 +341,16 @@ class _PrinterTerm(Printer):
 
     @override
     def progress_update(self, text: str, percent_done: float | None = None) -> None:
+        if self._settings and self._settings.silent:
+            return
+
         wandb.termlog(f"{next(self._progress)} {text}", newline=False)
 
     @override
     def progress_close(self, text: str | None = None) -> None:
+        if self._settings and self._settings.silent:
+            return
+
         text = text or " " * 79
         wandb.termlog(text)
 
@@ -422,8 +446,9 @@ class _DynamicTermText(DynamicText):
 
 
 class _PrinterJupyter(Printer):
-    def __init__(self) -> None:
+    def __init__(self, *, settings: wandb.Settings | None) -> None:
         super().__init__()
+        self._settings = settings
         self._progress = ipython.jupyter_progress_bar()
 
         from IPython import display
@@ -433,6 +458,10 @@ class _PrinterJupyter(Printer):
     @override
     @contextlib.contextmanager
     def dynamic_text(self) -> Iterator[DynamicText | None]:
+        if self._settings and self._settings.silent:
+            yield None
+            return
+
         handle = self._ipython_display.display(
             self._ipython_display.HTML(""),
             display_id=True,
@@ -452,7 +481,7 @@ class _PrinterJupyter(Printer):
         *,
         level: str | int | None = None,
     ) -> None:
-        if wandb.run and wandb.run._settings.silent:
+        if self._settings and self._settings.silent:
             return
 
         text = "<br>".join(text) if isinstance(text, (list, tuple)) else text
@@ -507,7 +536,7 @@ class _PrinterJupyter(Printer):
         text: str,
         percent_done: float | None = None,
     ) -> None:
-        if not self._progress:
+        if (self._settings and self._settings.silent) or not self._progress:
             return
 
         if percent_done is None: