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

wandb/sdk/data_types/html.py

@@ -16,19 +16,46 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Html(BatchableMedia):
-    """Wandb class for arbitrary html.
-
-    Args:
-        data: (string or io object) HTML to display in wandb
-        inject: (boolean) Add a stylesheet to the HTML object.  If set
-            to False the HTML will pass through unchanged.
-    """
+    """A class for logging HTML content to W&B."""
 
     _log_type = "html-file"
 
-    def __init__(self, data: Union[str, "TextIO"], inject: bool = True) -> None:
+    def __init__(
+        self,
+        data: Union[str, "TextIO"],
+        inject: bool = True,
+        data_is_not_path: bool = False,
+    ) -> None:
+        """Creates a W&B HTML object.
+
+        It can be initialized by providing a path to a file:
+        ```
+        with wandb.init() as run:
+            run.log({"html": wandb.Html("./index.html")})
+        ```
+
+        Alternatively, it can be initialized by providing literal HTML,
+        in either a string or IO object:
+        ```
+        with wandb.init() as run:
+            run.log({"html": wandb.Html("<h1>Hello, world!</h1>")})
+        ```
+
+        Args:
+            data:
+                A string that is a path to a file with the extension ".html",
+                or a string or IO object containing literal HTML.
+            inject: Add a stylesheet to the HTML object. If set
+                to False the HTML will pass through unchanged.
+            data_is_not_path: If set to False, the data will be
+                treated as a path to a file.
+        """
         super().__init__()
-        data_is_path = isinstance(data, str) and os.path.exists(data)
+        data_is_path = (
+            isinstance(data, str)
+            and os.path.isfile(data)
+            and os.path.splitext(data)[1] == ".html"
+        ) and not data_is_not_path
         data_path = ""
         if data_is_path:
             assert isinstance(data, str)

wandb/sdk/data_types/image.py

@@ -34,8 +34,8 @@ if TYPE_CHECKING:  # pragma: no cover
     TorchTensorType = Union["torch.Tensor", "torch.Variable"]
 
 
-def _server_accepts_image_filenames() -> bool:
-    if util._is_offline():
+def _server_accepts_image_filenames(run: "LocalRun") -> bool:
+    if run.offline:
         return True
 
     # Newer versions of wandb accept large image filenames arrays
@@ -51,15 +51,15 @@ def _server_accepts_image_filenames() -> bool:
     return accepts_image_filenames
 
 
-def _server_accepts_artifact_path() -> bool:
-    from wandb.util import parse_version
+def _server_accepts_artifact_path(run: "LocalRun") -> bool:
+    if run.offline:
+        return False
+
+    max_cli_version = util._get_max_cli_version()
+    if max_cli_version is None:
+        return False
 
-    target_version = "0.12.14"
-    max_cli_version = util._get_max_cli_version() if not util._is_offline() else None
-    accepts_artifact_path: bool = max_cli_version is not None and parse_version(
-        target_version
-    ) <= parse_version(max_cli_version)
-    return accepts_artifact_path
+    return util.parse_version("0.12.14") <= util.parse_version(max_cli_version)
 
 
 class Image(BatchableMedia):
@@ -401,7 +401,7 @@ class Image(BatchableMedia):
             )
 
         if (
-            not _server_accepts_artifact_path()
+            not _server_accepts_artifact_path(run)
             or self._get_artifact_entry_ref_url() is None
         ):
             super().bind_to_run(run, key, step, id_, ignore_copy_err=ignore_copy_err)
@@ -575,7 +575,7 @@ class Image(BatchableMedia):
             "format": format,
             "count": num_images_to_log,
         }
-        if _server_accepts_image_filenames():
+        if _server_accepts_image_filenames(run):
             meta["filenames"] = [
                 obj.get("path", obj.get("artifact_path")) for obj in jsons
             ]

wandb/sdk/data_types/table.py

@@ -480,6 +480,11 @@ class Table(Media):
             max_rows = Table.MAX_ROWS
         n_rows = len(self.data)
         if n_rows > max_rows and warn:
+            # NOTE: Never raises for reinit="create_new" runs.
+            #   Since this is called by bind_to_run(), this can be fixed by
+            #   propagating the run. It cannot be fixed for to_json() calls
+            #   that are given an artifact, other than by deferring to singleton
+            #   settings.
             if wandb.run and (
                 wandb.run.settings.table_raise_on_max_row_limit_exceeded
                 or wandb.run.settings.strict

wandb/sdk/data_types/trace_tree.py

@@ -431,6 +431,8 @@ class Trace:
             name: The name of the trace to be logged
         """
         trace_tree = WBTraceTree(self._span, self._model_dict)
+        # NOTE: Does not work for reinit="create_new" runs.
+        #   This method should be deprecated and users should call run.log().
         assert (
             wandb.run is not None
         ), "You must call wandb.init() before logging a trace"

wandb/sdk/data_types/utils.py

@@ -101,7 +101,7 @@ def val_to_json(
 
             items = _prune_max_seq(val)
 
-            if _server_accepts_image_filenames():
+            if _server_accepts_image_filenames(run):
                 for item in items:
                     item.bind_to_run(
                         run=run,

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, 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
@@ -134,7 +135,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 +157,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:

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/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:

wandb/sdk/lib/printer_asyncio.py

@@ -0,0 +1,46 @@
+import asyncio
+from typing import Callable, TypeVar
+
+from wandb.sdk.lib import asyncio_compat, printer
+
+_T = TypeVar("_T")
+
+
+def run_async_with_spinner(
+    spinner_printer: printer.Printer,
+    text: str,
+    func: Callable[[], _T],
+) -> _T:
+    """Run a slow function while displaying a loading icon.
+
+    Args:
+        spinner_printer: The printer to use to display text.
+        text: The text to display next to the spinner while the function runs.
+        func: The function to run.
+
+    Returns:
+        The result of func.
+    """
+
+    async def _loop_run_with_spinner() -> _T:
+        func_running = asyncio.Event()
+
+        async def update_spinner() -> None:
+            tick = 0
+            with spinner_printer.dynamic_text() as text_area:
+                if text_area:
+                    while not func_running.is_set():
+                        spinner = spinner_printer.loading_symbol(tick)
+                        text_area.set_text(f"{spinner} {text}")
+                        tick += 1
+                        await asyncio.sleep(0.1)
+                else:
+                    spinner_printer.display(text)
+
+        async with asyncio_compat.open_task_group() as group:
+            group.start_soon(update_spinner())
+            res = await asyncio.get_running_loop().run_in_executor(None, func)
+            func_running.set()
+            return res
+
+    return asyncio_compat.run(_loop_run_with_spinner)

wandb/sdk/lib/redirect.py

@@ -534,12 +534,15 @@ class StreamWrapper(RedirectBase):
         self,
         src: Literal["stdout", "stderr"],
         cbs: Iterable[Callable[[str], None]] = (),
+        *,
+        flush_periodically: bool,
     ) -> None:
         super().__init__(src=src, cbs=cbs)
         self._uninstall: Callable[[], None] | None = None
         self._emulator = TerminalEmulator()
         self._queue: queue.Queue[str] = queue.Queue()
         self._stopped = threading.Event()
+        self._flush_periodically = flush_periodically
 
     def _emulator_write(self) -> None:
         while True:
@@ -600,7 +603,7 @@ class StreamWrapper(RedirectBase):
         self._emulator_write_thread.daemon = True
         self._emulator_write_thread.start()
 
-        if not wandb.run or wandb.run._settings.mode == "online":
+        if self._flush_periodically:
             self._callback_thread = threading.Thread(target=self._callback)
             self._callback_thread.daemon = True
             self._callback_thread.start()
@@ -732,10 +735,11 @@ _redirects: dict[str, Redirect | None] = {"stdout": None, "stderr": None}
 class Redirect(RedirectBase):
     """Redirect low level file descriptors."""
 
-    def __init__(self, src, cbs=()):
+    def __init__(self, src, cbs=(), *, flush_periodically: bool):
         super().__init__(src=src, cbs=cbs)
         self._installed = False
         self._emulator = TerminalEmulator()
+        self._flush_periodically = flush_periodically
 
     def _pipe(self):
         if pty:
@@ -767,7 +771,7 @@ class Redirect(RedirectBase):
         self._emulator_write_thread = threading.Thread(target=self._emulator_write)
         self._emulator_write_thread.daemon = True
         self._emulator_write_thread.start()
-        if not wandb.run or wandb.run._settings.mode == "online":
+        if self._flush_periodically:
             self._callback_thread = threading.Thread(target=self._callback)
             self._callback_thread.daemon = True
             self._callback_thread.start()
@@ -776,8 +780,9 @@ class Redirect(RedirectBase):
         if not self._installed:
             return
         self._installed = False
-        # If the user printed a very long string (millions of chars) right before wandb.finish(),
-        # it will take a while for it to reach pipe relay. 1 second is enough time for ~5 million chars.
+        # If the user printed a very long string (millions of chars) right
+        # before run.finish(), it will take a while for it to reach pipe relay.
+        # 1 second is enough time for ~5 million chars.
         time.sleep(1)
         self._stopped.set()
         os.dup2(self._orig_src_fd, self.src_fd)