wandb 0.19.8__py3-none-any.whl → 0.19.10__py3-none-any.whl

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)

wandb/sdk/lib/run_moment.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Literal, cast
+from typing import Union
 from urllib import parse
 
-_STEP = Literal["_step"]
-
 
 @dataclass
 class RunMoment:
@@ -19,10 +17,10 @@ class RunMoment:
     run: str
     """run ID"""
 
-    value: int | float
+    value: Union[int, float]
     """Value of the metric."""
 
-    metric: _STEP = "_step"
+    metric: str = "_step"
     """Metric to use to determine the moment in the run.
 
     Currently, only the metric '_step' is supported.
@@ -81,4 +79,4 @@ class RunMoment:
         except ValueError as e:
             raise parse_err from e
 
-        return cls(run=run, metric=cast(_STEP, metric), value=num_value)
+        return cls(run=run, metric=metric, value=num_value)

wandb/sdk/lib/wb_logging.py

@@ -0,0 +1,161 @@
+"""Logging configuration for the "wandb" logger.
+
+Most log statements in wandb are made in the context of a run and should be
+redirected to that run's log file (usually named 'debug.log'). This module
+provides a context manager to temporarily set the current run ID and registers
+a global handler for the 'wandb' logger that sends log statements to the right
+place.
+
+All functions in this module are threadsafe.
+
+NOTE: The pytest caplog fixture will fail to capture logs from the wandb logger
+because they are not propagated to the root logger.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import contextvars
+import logging
+import pathlib
+from typing import Iterator
+
+
+class _NotRunSpecific:
+    """Sentinel for `not_run_specific()`."""
+
+
+_NOT_RUN_SPECIFIC = _NotRunSpecific()
+
+
+_run_id: contextvars.ContextVar[str | _NotRunSpecific | None] = contextvars.ContextVar(
+    "_run_id",
+    default=None,
+)
+
+_logger = logging.getLogger("wandb")
+
+
+def configure_wandb_logger() -> None:
+    """Configures the global 'wandb' logger.
+
+    The wandb logger is not intended to be customized by users. Instead, it is
+    used as a mechanism to redirect log messages into wandb run-specific log
+    files.
+
+    This function is idempotent: calling it multiple times has the same effect.
+    """
+    # Send all DEBUG and above messages to registered handlers.
+    #
+    # Per-run handlers can set different levels.
+    _logger.setLevel(logging.DEBUG)
+
+    # Do not propagate wandb logs to the root logger, which the user may have
+    # configured to point elsewhere. All wandb log messages should go to a run's
+    # log file.
+    _logger.propagate = False
+
+    # If no handlers are configured for the 'wandb' logger, don't activate the
+    # "lastResort" handler which sends messages to stderr with a level of
+    # WARNING by default.
+    #
+    # This occurs in wandb code that runs outside the context of a Run and
+    # not as part of the CLI.
+    #
+    # Most such code uses the `termlog` / `termwarn` / `termerror` methods
+    # to communicate with the user. When that code executes while a run is
+    # active, its logger messages go to that run's log file.
+    if not _logger.handlers:
+        _logger.addHandler(logging.NullHandler())
+
+
+@contextlib.contextmanager
+def log_to_run(run_id: str | None) -> Iterator[None]:
+    """Direct all wandb log messages to the given run.
+
+    Args:
+        id: The current run ID, or None if actions in the context manager are
+            not associated to a specific run. In the latter case, log messages
+            will go to all runs.
+
+    Usage:
+
+        with wb_logging.run_id(...):
+            ... # Log messages here go to the specified run's logger.
+    """
+    token = _run_id.set(run_id)
+    try:
+        yield
+    finally:
+        _run_id.reset(token)
+
+
+@contextlib.contextmanager
+def log_to_all_runs() -> Iterator[None]:
+    """Direct wandb log messages to all runs.
+
+    Unlike `log_to_run(None)`, this indicates an intentional choice.
+    This is often convenient to use as a decorator:
+
+        @wb_logging.log_to_all_runs()
+        def my_func():
+            ... # Log messages here go to the specified run's logger.
+    """
+    token = _run_id.set(_NOT_RUN_SPECIFIC)
+    try:
+        yield
+    finally:
+        _run_id.reset(token)
+
+
+def add_file_handler(run_id: str, filepath: pathlib.Path) -> logging.Handler:
+    """Direct log messages for a run to a file.
+
+    Args:
+        run_id: The run for which to create a log file.
+        filepath: The file to write log messages to.
+
+    Returns:
+        The added handler which can then be configured further or removed
+        from the 'wandb' logger directly.
+
+        The default logging level is INFO.
+    """
+    handler = logging.FileHandler(filepath)
+    handler.setLevel(logging.INFO)
+    handler.addFilter(_RunIDFilter(run_id))
+    handler.setFormatter(
+        logging.Formatter(
+            "%(asctime)s %(levelname)-7s %(threadName)-10s:%(process)d"
+            " [%(filename)s:%(funcName)s():%(lineno)s]%(run_id_tag)s"
+            " %(message)s"
+        )
+    )
+
+    _logger.addHandler(handler)
+    return handler
+
+
+class _RunIDFilter(logging.Filter):
+    """Filters out messages logged for a different run."""
+
+    def __init__(self, run_id: str) -> None:
+        """Create a _RunIDFilter.
+
+        Args:
+            run_id: Allows messages when the run ID is this or None.
+        """
+        self._run_id = run_id
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        run_id = _run_id.get()
+
+        if run_id is None:
+            record.run_id_tag = " [no run ID]"
+            return True
+        elif isinstance(run_id, _NotRunSpecific):
+            record.run_id_tag = " [all runs]"
+            return True
+        else:
+            record.run_id_tag = ""
+            return run_id == self._run_id

wandb/sdk/service/server_sock.py

@@ -5,6 +5,7 @@ import time
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
 
 import wandb
+from wandb.proto import wandb_internal_pb2 as pb
 from wandb.proto import wandb_server_pb2 as spb
 from wandb.sdk.internal.settings_static import SettingsStatic
 
@@ -156,27 +157,31 @@ class SockServerReadThread(threading.Thread):
             inform_attach_response=inform_attach_response,
         )
         self._sock_client.send_server_response(response)
-        iface = self._mux.get_stream(stream_id).interface
-
-        assert iface
 
     def server_record_communicate(self, sreq: "spb.ServerRequest") -> None:
-        record = sreq.record_communicate
-        # encode relay information so the right socket picks up the data
-        record.control.relay_id = self._sock_client._sockid
-        stream_id = record._info.stream_id
-        iface = self._mux.get_stream(stream_id).interface
-        assert iface.record_q
-        iface.record_q.put(record)
+        self._put_record(sreq.record_communicate)
 
     def server_record_publish(self, sreq: "spb.ServerRequest") -> None:
-        record = sreq.record_publish
+        self._put_record(sreq.record_publish)
+
+    def _put_record(self, record: "pb.Record") -> None:
         # encode relay information so the right socket picks up the data
         record.control.relay_id = self._sock_client._sockid
         stream_id = record._info.stream_id
-        iface = self._mux.get_stream(stream_id).interface
-        assert iface.record_q
-        iface.record_q.put(record)
+
+        try:
+            iface = self._mux.get_stream(stream_id).interface
+
+        except KeyError:
+            # We should log the error but cannot because it may print to console
+            # due to how logging is set up. This error usually happens if
+            # a record is sent when no run is active, but during this time the
+            # logger prints to the console.
+            pass
+
+        else:
+            assert iface.record_q
+            iface.record_q.put(record)
 
     def server_inform_finish(self, sreq: "spb.ServerRequest") -> None:
         request = sreq.inform_finish

wandb/sdk/service/service.py

@@ -14,10 +14,10 @@ import tempfile
 import time
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
-from wandb import _sentry, termlog
+from wandb import _sentry
 from wandb.env import core_debug, error_reporting_enabled, is_require_legacy_service
 from wandb.errors import Error, WandbCoreNotAvailableError
-from wandb.errors.links import url_registry
+from wandb.errors.term import termlog, termwarn
 from wandb.util import get_core_path, get_module
 
 from . import _startup_debug, port_file
@@ -163,13 +163,15 @@ class _Service:
                     service_args.extend(["--log-level", "-4"])
 
                 exec_cmd_list = []
-                termlog(
-                    "Using wandb-core as the SDK backend.  Please refer to "
-                    f"{url_registry.url('wandb-core')} for more information.",
-                    repeat=False,
-                )
             else:
                 service_args.extend(["wandb", "service", "--debug"])
+                termwarn(
+                    "Using legacy-service, which is deprecated. If this is"
+                    " unintentional, you can fix it by ensuring you do not call"
+                    " `wandb.require('legacy-service')` and do not set the"
+                    " WANDB_X_REQUIRE_LEGACY_SERVICE environment"
+                    " variable."
+                )
 
             service_args += [
                 "--port-filename",

wandb/sdk/service/streams.py

@@ -198,6 +198,11 @@ class StreamMux:
             return stream_id in self._streams
 
     def get_stream(self, stream_id: str) -> StreamRecord:
+        """Returns the StreamRecord for the ID.
+
+        Raises:
+            KeyError: If a corresponding StreamRecord does not exist.
+        """
         with self._streams_lock:
             stream = self._streams[stream_id]
             return stream

wandb/sdk/verify/verify.py

@@ -132,7 +132,10 @@ def check_run(api: Api) -> bool:
     f.close()
 
     with wandb.init(
-        id=nice_id("check_run"), reinit=True, config=config, project=PROJECT_NAME
+        id=nice_id("check_run"),
+        reinit=True,
+        config=config,
+        project=PROJECT_NAME,
     ) as run:
         run_id = run.id
         entity = run.entity
@@ -155,7 +158,7 @@ def check_run(api: Api) -> bool:
                 "Failed to log to media. Contact W&B for support."
             )
 
-        wandb.save(filepath)
+        run.save(filepath)
     public_api = wandb.Api()
     prev_run = public_api.run(f"{entity}/{PROJECT_NAME}/{run_id}")
     # raise Exception(prev_run.__dict__)
@@ -379,7 +382,7 @@ def check_graphql_put(api: Api, host: str) -> Tuple[bool, Optional[str]]:
         project=PROJECT_NAME,
         config={"test": "put to graphql"},
     ) as run:
-        wandb.save(gql_fp)
+        run.save(gql_fp)
     public_api = wandb.Api()
     prev_run = public_api.run(f"{run.entity}/{PROJECT_NAME}/{run.id}")
     if prev_run is None: