wandb 0.18.1__py3-none-any.whl → 0.18.2__py3-none-any.whl

wandb/sdk/wandb_run.py

@@ -44,6 +44,7 @@ from wandb.apis.internal import Api
 from wandb.apis.public import Api as PublicApi
 from wandb.errors import CommError
 from wandb.integration.torch import wandb_torch
+from wandb.plot.viz import CustomChart, Visualize, custom_chart
 from wandb.proto.wandb_internal_pb2 import (
     MetricRecord,
     PollExitResponse,
@@ -57,7 +58,6 @@ from wandb.sdk.lib.import_hooks import (
     unregister_post_import_hook,
 )
 from wandb.sdk.lib.paths import FilePathStr, LogicalPath, StrPath
-from wandb.sdk.lib.viz import CustomChart, Visualize, custom_chart
 from wandb.util import (
     _is_artifact_object,
     _is_artifact_string,
@@ -592,12 +592,14 @@ class Run:
     ) -> None:
         # pid is set, so we know if this run object was initialized by this process
         self._init_pid = os.getpid()
-        self._settings = settings
 
         if settings._noop:
+            # TODO: properly handle setting for disabled mode
+            self._settings = settings
             return
 
         self._init(
+            settings=settings,
             config=config,
             sweep_config=sweep_config,
             launch_config=launch_config,
@@ -605,10 +607,13 @@ class Run:
 
     def _init(
         self,
+        settings: Settings,
         config: Optional[Dict[str, Any]] = None,
         sweep_config: Optional[Dict[str, Any]] = None,
         launch_config: Optional[Dict[str, Any]] = None,
     ) -> None:
+        self._settings = settings
+
         self._config = wandb_config.Config()
         self._config._set_callback(self._config_callback)
         self._config._set_artifact_callback(self._config_artifact_callback)
@@ -2194,9 +2199,9 @@ class Run:
             # Inform the service that we're done sending messages for this run.
             #
             # TODO: Why not do this in _atexit_cleanup()?
-            manager = self._wl and self._wl._get_manager()
-            if manager:
-                manager._inform_finish(run_id=self._run_id)
+            service = self._wl and self._wl.service
+            if service:
+                service.inform_finish(run_id=self._run_id)
 
         finally:
             module.unset_globals()
@@ -2459,8 +2464,8 @@ class Run:
         logger.info("atexit reg")
         self._hooks = ExitHooks()
 
-        manager = self._wl and self._wl._get_manager()
-        if not manager:
+        service = self._wl and self._wl.service
+        if not service:
             self._hooks.hook()
             # NB: manager will perform atexit hook like behavior for outstanding runs
             atexit.register(lambda: self._atexit_cleanup())

wandb/sdk/wandb_settings.py

@@ -315,6 +315,7 @@ class SettingsData:
     _executable: str
     _extra_http_headers: Mapping[str, str]
     _file_stream_max_bytes: int  # max size for filestream requests in core
+    _file_stream_transmit_interval: float  # tx interval for filestream requests in core
     # file stream retry client configuration
     _file_stream_retry_max: int  # max number of retries
     _file_stream_retry_wait_min_seconds: float  # min wait time between retries
@@ -664,6 +665,7 @@ class Settings(SettingsData):
             _disable_viewer={"preprocessor": _str_as_bool},
             _extra_http_headers={"preprocessor": _str_as_json},
             _file_stream_max_bytes={"preprocessor": int},
+            _file_stream_transmit_interval={"preprocessor": float},
             _file_stream_retry_max={"preprocessor": int},
             _file_stream_retry_wait_min_seconds={"preprocessor": float},
             _file_stream_retry_wait_max_seconds={"preprocessor": float},

wandb/sdk/wandb_setup.py

@@ -20,7 +20,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 import wandb
 from wandb.sdk.lib import import_hooks
 
-from . import wandb_manager, wandb_settings
+from . import wandb_settings
 from .lib import config_util, server, tracelog
 
 Settings = Union["wandb.sdk.wandb_settings.Settings", Dict[str, Any]]
@@ -28,6 +28,8 @@ Settings = Union["wandb.sdk.wandb_settings.Settings", Dict[str, Any]]
 Logger = Union[logging.Logger, "_EarlyLogger"]
 
 if TYPE_CHECKING:
+    from wandb.sdk.lib import service_connection
+
     from . import wandb_run
 
 # logger will be configured to be either a standard logger instance or _EarlyLogger
@@ -82,20 +84,18 @@ class _EarlyLogger:
 class _WandbSetup__WandbSetup:  # noqa: N801
     """Inner class of _WandbSetup."""
 
-    _manager: Optional[wandb_manager._Manager]
-    _pid: int
-
     def __init__(
         self,
         pid: int,
         settings: Optional[Settings] = None,
         environ: Optional[Dict[str, Any]] = None,
     ) -> None:
+        self._connection: Optional[service_connection.ServiceConnection] = None
+
         self._environ = environ or dict(os.environ)
         self._sweep_config: Optional[Dict[str, Any]] = None
         self._config: Optional[Dict[str, Any]] = None
         self._server: Optional[server.Server] = None
-        self._manager: Optional[wandb_manager._Manager] = None
         self._pid = pid
 
         # keep track of multiple runs, so we can unwind with join()s
@@ -248,7 +248,10 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             print("frozen, could be trouble")
 
     def _setup(self) -> None:
-        self._setup_manager()
+        if not self._settings._noop and not self._settings._disable_service:
+            from wandb.sdk.lib import service_connection
+
+            self._connection = service_connection.connect_to_service(self._settings)
 
         sweep_path = self._settings.sweep_param_path
         if sweep_path:
@@ -271,22 +274,21 @@ class _WandbSetup__WandbSetup:  # noqa: N801
     def _teardown(self, exit_code: Optional[int] = None) -> None:
         import_hooks.unregister_all_post_import_hooks()
 
-        if not self._manager:
+        if not self._connection:
             return
 
-        internal_exit_code = self._manager._teardown(exit_code or 0)
-        self._manager = None
+        internal_exit_code = self._connection.teardown(exit_code or 0)
+
+        # Reset to None so that setup() creates a new connection.
+        self._connection = None
 
         if internal_exit_code != 0:
             sys.exit(internal_exit_code)
 
-    def _setup_manager(self) -> None:
-        if self._settings._noop or self._settings._disable_service:
-            return
-        self._manager = wandb_manager._Manager(settings=self._settings)
-
-    def _get_manager(self) -> Optional[wandb_manager._Manager]:
-        return self._manager
+    @property
+    def service(self) -> "Optional[service_connection.ServiceConnection]":
+        """Returns a connection to the service process, if it exists."""
+        return self._connection
 
 
 class _WandbSetup:
@@ -305,6 +307,13 @@ class _WandbSetup:
             return
         _WandbSetup._instance = _WandbSetup__WandbSetup(settings=settings, pid=pid)
 
+    @property
+    def service(self) -> "Optional[service_connection.ServiceConnection]":
+        """Returns a connection to the service process, if it exists."""
+        if not self._instance:
+            return None
+        return self._instance.service
+
     def __getattr__(self, name: str) -> Any:
         return getattr(self._instance, name)
 

wandb/sdk/wandb_sync.py

@@ -37,11 +37,17 @@ def _sync(
     if append:
         settings.resume.value = "allow"
 
-    manager = wl._get_manager()
-    manager._inform_init(settings=settings, run_id=stream_id)
+    service = wl.service
+    assert service
+
+    service.inform_init(settings=settings, run_id=stream_id)
 
     mailbox = Mailbox()
-    backend = Backend(settings=wl.settings, manager=manager, mailbox=mailbox)
+    backend = Backend(
+        settings=wl.settings,
+        service=service,
+        mailbox=mailbox,
+    )
     backend.ensure_launched()
 
     assert backend.interface

wandb/sdk/wandb_watch.py

@@ -1,7 +1,9 @@
 """watch."""
 
+from __future__ import annotations
+
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING, Sequence
 
 try:
     from typing import Literal
@@ -12,36 +14,50 @@ import wandb
 
 from .lib import telemetry
 
+if TYPE_CHECKING:
+    import torch  # type: ignore [import-not-found]
+
 logger = logging.getLogger("wandb")
 
 _global_watch_idx = 0
 
 
 def watch(
-    models,
-    criterion=None,
-    log: Optional[Literal["gradients", "parameters", "all"]] = "gradients",
+    models: torch.nn.Module | Sequence[torch.nn.Module],
+    criterion: torch.F | None = None,
+    log: Literal["gradients", "parameters", "all"] | None = "gradients",
     log_freq: int = 1000,
-    idx: Optional[int] = None,
+    idx: int | None = None,
     log_graph: bool = False,
 ):
-    """Hook into the torch model to collect gradients and the topology.
+    """Hooks into the given PyTorch model(s) to monitor gradients and the model's computational graph.
 
-    Should be extended to accept arbitrary ML models.
+    This function can track parameters, gradients, or both during training. It should be
+    extended to support arbitrary machine learning models in the future.
 
     Args:
-        models: (torch.Module) The model to hook, can be a tuple
-        criterion: (torch.F) An optional loss value being optimized
-        log: (str) One of "gradients", "parameters", "all", or None
-        log_freq: (int) log gradients and parameters every N batches
-        idx: (int) an index to be used when calling wandb.watch on multiple models
-        log_graph: (boolean) log graph topology
+        models (Union[torch.nn.Module, Sequence[torch.nn.Module]]):
+            A single model or a sequence of models to be monitored.
+        criterion (Optional[torch.F]):
+            The loss function being optimized (optional).
+        log (Optional[Literal["gradients", "parameters", "all"]]):
+            Specifies whether to log "gradients", "parameters", or "all".
+            Set to None to disable logging. (default="gradients")
+        log_freq (int):
+            Frequency (in batches) to log gradients and parameters. (default=1000)
+        idx (Optional[int]):
+            Index used when tracking multiple models with `wandb.watch`. (default=None)
+         log_graph (bool):
+            Whether to log the model's computational graph. (default=False)
 
     Returns:
-        `wandb.Graph`: The graph object that will populate after the first backward pass
+        wandb.Graph:
+            The graph object, which will be populated after the first backward pass.
 
     Raises:
-        ValueError: If called before `wandb.init` or if any of models is not a torch.nn.Module.
+        ValueError:
+            If `wandb.init` has not been called or if any of the models are not instances
+            of `torch.nn.Module`.
     """
     global _global_watch_idx
 

wandb/util.py

@@ -1888,7 +1888,14 @@ def working_set() -> Iterable[InstalledDistribution]:
         from importlib_metadata import distributions  # type: ignore
 
     for d in distributions():
-        yield InstalledDistribution(key=d.metadata["Name"], version=d.version)
+        try:
+            # In some distributions, the "Name" attribute may not be present,
+            # which can raise a KeyError. To handle this, we catch the exception
+            # and skip those distributions.
+            # For additional context, see: https://github.com/python/importlib_metadata/issues/371.
+            yield InstalledDistribution(key=d.metadata["Name"], version=d.version)
+        except KeyError:
+            pass
 
 
 def parse_version(version: str) -> "packaging.version.Version":

{wandb-0.18.1.dist-info → wandb-0.18.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.18.1
+Version: 0.18.2
 Summary: A CLI and library for interacting with the Weights & Biases API.
 Project-URL: Source, https://github.com/wandb/wandb
 Project-URL: Bug Reports, https://github.com/wandb/wandb/issues
@@ -105,6 +105,7 @@ Requires-Dist: tomli; extra == 'launch'
 Requires-Dist: typing-extensions; extra == 'launch'
 Provides-Extra: media
 Requires-Dist: bokeh; extra == 'media'
+Requires-Dist: imageio; extra == 'media'
 Requires-Dist: moviepy; extra == 'media'
 Requires-Dist: numpy; extra == 'media'
 Requires-Dist: pillow; extra == 'media'