wandb 0.18.0rc1__py3-none-any.whl → 0.18.2__py3-none-any.whl

wandb/sdk/wandb_run.py

@@ -43,12 +43,13 @@ from wandb.apis import internal, public
 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,
     Result,
     RunRecord,
-    ServerInfoResponse,
 )
 from wandb.sdk.artifacts.artifact import Artifact
 from wandb.sdk.internal import job_builder
@@ -57,12 +58,11 @@ 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,
     _is_artifact_version_weave_dict,
-    _is_py_or_dockerfile,
+    _is_py_requirements_or_dockerfile,
     _resolve_aliases,
     add_import_hook,
     parse_artifact_string,
@@ -105,7 +105,6 @@ if TYPE_CHECKING:
     import wandb.sdk.backend.backend
     import wandb.sdk.interface.interface_queue
     from wandb.proto.wandb_internal_pb2 import (
-        CheckVersionResponse,
         GetSummaryResponse,
         InternalMessagesResponse,
         SampledHistoryResponse,
@@ -561,12 +560,10 @@ class Run:
 
     _run_status_checker: Optional[RunStatusChecker]
 
-    _check_version: Optional["CheckVersionResponse"]
     _sampled_history: Optional["SampledHistoryResponse"]
     _final_summary: Optional["GetSummaryResponse"]
     _poll_exit_handle: Optional[MailboxHandle]
     _poll_exit_response: Optional[PollExitResponse]
-    _server_info_response: Optional[ServerInfoResponse]
     _internal_messages_response: Optional["InternalMessagesResponse"]
 
     _stdout_slave_fd: Optional[int]
@@ -595,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,
@@ -608,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)
@@ -624,7 +626,7 @@ class Run:
         )
         self.summary._set_update_callback(self._summary_update_callback)
         self._step = 0
-        self._torch_history: Optional[wandb.wandb_torch.TorchHistory] = None  # type: ignore
+        self._torch_history: Optional[wandb_torch.TorchHistory] = None  # type: ignore
 
         # todo: eventually would be nice to make this configurable using self._settings._start_time
         #  need to test (jhr): if you set start time to 2 days ago and run a test for 15 minutes,
@@ -669,11 +671,9 @@ class Run:
         # Created when the run "starts".
         self._run_status_checker = None
 
-        self._check_version = None
         self._sampled_history = None
         self._final_summary = None
         self._poll_exit_response = None
-        self._server_info_response = None
         self._internal_messages_response = None
         self._poll_exit_handle = None
 
@@ -927,9 +927,9 @@ class Run:
         self.__dict__.update(state)
 
     @property
-    def _torch(self) -> "wandb.wandb_torch.TorchHistory":  # type: ignore
+    def _torch(self) -> "wandb_torch.TorchHistory":  # type: ignore
         if self._torch_history is None:
-            self._torch_history = wandb.wandb_torch.TorchHistory()  # type: ignore
+            self._torch_history = wandb_torch.TorchHistory()  # type: ignore
         return self._torch_history
 
     @property
@@ -1152,7 +1152,7 @@ class Run:
         name: Optional[str] = None,
         include_fn: Union[
             Callable[[str, str], bool], Callable[[str], bool]
-        ] = _is_py_or_dockerfile,
+        ] = _is_py_requirements_or_dockerfile,
         exclude_fn: Union[
             Callable[[str, str], bool], Callable[[str], bool]
         ] = filenames.exclude_wandb_fn,
@@ -2199,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()
@@ -2453,8 +2453,6 @@ class Run:
             sampled_history=self._sampled_history,
             final_summary=self._final_summary,
             poll_exit_response=self._poll_exit_response,
-            server_info_response=self._server_info_response,
-            check_version_response=self._check_version,
             internal_messages_response=self._internal_messages_response,
             reporter=self._reporter,
             quiet=self._quiet,
@@ -2466,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())
@@ -2676,25 +2674,6 @@ class Run:
 
         assert self._backend and self._backend.interface
 
-        if not self._settings._disable_update_check:
-            logger.info("communicating current version")
-            version_handle = self._backend.interface.deliver_check_version(
-                current_version=wandb.__version__
-            )
-            version_result = version_handle.wait(timeout=10)
-            if not version_result:
-                version_handle.abandon()
-            else:
-                self._check_version = version_result.response.check_version_response
-                logger.info("got version response %s", self._check_version)
-
-        # get the server info before starting the defer state machine as
-        # it will stop communication with the server
-        server_info_handle = self._backend.interface.deliver_request_server_info()
-        result = server_info_handle.wait(timeout=-1)
-        assert result
-        self._server_info_response = result.response.server_info_response
-
         exit_handle = self._backend.interface.deliver_exit(self._exit_code)
         exit_handle.add_probe(on_probe=self._on_probe_exit)
 
@@ -3712,27 +3691,6 @@ class Run:
         Run._header_sync_info(settings=settings, printer=printer)
         Run._header_run_info(settings=settings, printer=printer)
 
-    @staticmethod
-    def _header_version_check_info(
-        check_version: Optional["CheckVersionResponse"] = None,
-        *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
-    ) -> None:
-        if not check_version or settings._offline:
-            return
-
-        if check_version.delete_message:
-            printer.display(check_version.delete_message, level="error")
-        elif check_version.yank_message:
-            printer.display(check_version.yank_message, level="warn")
-
-        printer.display(
-            check_version.upgrade_message,
-            off=not check_version.upgrade_message,
-            level="warn",
-        )
-
     @staticmethod
     def _header_wandb_version_info(
         *,
@@ -3846,8 +3804,6 @@ class Run:
         sampled_history: Optional["SampledHistoryResponse"] = None,
         final_summary: Optional["GetSummaryResponse"] = None,
         poll_exit_response: Optional[PollExitResponse] = None,
-        server_info_response: Optional[ServerInfoResponse] = None,
-        check_version_response: Optional["CheckVersionResponse"] = None,
         internal_messages_response: Optional["InternalMessagesResponse"] = None,
         reporter: Optional[Reporter] = None,
         quiet: Optional[bool] = None,
@@ -3870,23 +3826,11 @@ class Run:
             printer=printer,
         )
         Run._footer_log_dir_info(quiet=quiet, settings=settings, printer=printer)
-        Run._footer_version_check_info(
-            check_version=check_version_response,
-            quiet=quiet,
-            settings=settings,
-            printer=printer,
-        )
         Run._footer_notify_wandb_core(
             quiet=quiet,
             settings=settings,
             printer=printer,
         )
-        Run._footer_local_warn(
-            server_info_response=server_info_response,
-            quiet=quiet,
-            settings=settings,
-            printer=printer,
-        )
         Run._footer_internal_messages(
             internal_messages_response=internal_messages_response,
             quiet=quiet,
@@ -3896,12 +3840,6 @@ class Run:
         Run._footer_reporter_warn_err(
             reporter=reporter, quiet=quiet, settings=settings, printer=printer
         )
-        Run._footer_server_messages(
-            server_info_response=server_info_response,
-            quiet=quiet,
-            settings=settings,
-            printer=printer,
-        )
 
     # fixme: Temporary hack until we move to rich which allows multiple spinners
     @staticmethod
@@ -4156,33 +4094,6 @@ class Run:
         if panel:
             printer.display(printer.panel(panel))
 
-    @staticmethod
-    def _footer_local_warn(
-        server_info_response: Optional[ServerInfoResponse] = None,
-        quiet: Optional[bool] = None,
-        *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
-    ) -> None:
-        if (quiet or settings.quiet) or settings.silent:
-            return
-
-        if settings._offline:
-            return
-
-        if not server_info_response or not server_info_response.local_info:
-            return
-
-        if settings.is_local:
-            local_info = server_info_response.local_info
-            latest_version, out_of_date = local_info.version, local_info.out_of_date
-            if out_of_date:
-                printer.display(
-                    f"Upgrade to the {latest_version} version of W&B Server to get the latest features. "
-                    f"Learn more: {printer.link(wburls.get('upgrade_server'))}",
-                    level="warn",
-                )
-
     @staticmethod
     def _footer_internal_messages(
         internal_messages_response: Optional["InternalMessagesResponse"] = None,
@@ -4200,58 +4111,6 @@ class Run:
         for message in internal_messages_response.messages.warning:
             printer.display(message, level="warn")
 
-    @staticmethod
-    def _footer_server_messages(
-        server_info_response: Optional[ServerInfoResponse] = None,
-        quiet: Optional[bool] = None,
-        *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
-    ) -> None:
-        if (quiet or settings.quiet) or settings.silent:
-            return
-
-        if settings.disable_hints:
-            return
-
-        if server_info_response and server_info_response.server_messages:
-            for message in server_info_response.server_messages.item:
-                printer.display(
-                    message.html_text if printer._html else message.utf_text,
-                    default_text=message.plain_text,
-                    level=message.level,
-                    off=message.type.lower() != "footer",
-                )
-
-    @staticmethod
-    def _footer_version_check_info(
-        check_version: Optional["CheckVersionResponse"] = None,
-        quiet: Optional[bool] = None,
-        *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
-    ) -> None:
-        if not check_version:
-            return
-
-        if settings._offline:
-            return
-
-        if (quiet or settings.quiet) or settings.silent:
-            return
-
-        if check_version.delete_message:
-            printer.display(check_version.delete_message, level="error")
-        elif check_version.yank_message:
-            printer.display(check_version.yank_message, level="warn")
-
-        # only display upgrade message if packages are bad
-        if check_version.upgrade_message:
-            printer.display(
-                check_version.upgrade_message,
-                level="warn",
-            )
-
     @staticmethod
     def _footer_notify_wandb_core(
         *,

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._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/sklearn.py

@@ -0,0 +1,35 @@
+from wandb.integration.sklearn import (
+    plot_calibration_curve,
+    plot_class_proportions,
+    plot_classifier,
+    plot_clusterer,
+    plot_confusion_matrix,
+    plot_elbow_curve,
+    plot_feature_importances,
+    plot_learning_curve,
+    plot_outlier_candidates,
+    plot_precision_recall,
+    plot_regressor,
+    plot_residuals,
+    plot_roc,
+    plot_silhouette,
+    plot_summary_metrics,
+)
+
+__all__ = (
+    "plot_classifier",
+    "plot_clusterer",
+    "plot_regressor",
+    "plot_summary_metrics",
+    "plot_learning_curve",
+    "plot_feature_importances",
+    "plot_class_proportions",
+    "plot_calibration_curve",
+    "plot_roc",
+    "plot_precision_recall",
+    "plot_confusion_matrix",
+    "plot_elbow_curve",
+    "plot_silhouette",
+    "plot_residuals",
+    "plot_outlier_candidates",
+)

wandb/util.py

@@ -1554,9 +1554,13 @@ def _is_databricks() -> bool:
     return False
 
 
-def _is_py_or_dockerfile(path: str) -> bool:
+def _is_py_requirements_or_dockerfile(path: str) -> bool:
     file = os.path.basename(path)
-    return file.endswith(".py") or file.startswith("Dockerfile")
+    return (
+        file.endswith(".py")
+        or file.startswith("Dockerfile")
+        or file == "requirements.txt"
+    )
 
 
 def check_windows_valid_filename(path: Union[int, str]) -> bool:
@@ -1884,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.0rc1.dist-info → wandb-0.18.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.18.0rc1
+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
@@ -50,10 +50,10 @@ Requires-Dist: click!=8.0.0,>=7.1
 Requires-Dist: docker-pycreds>=0.4.0
 Requires-Dist: gitpython!=3.1.29,>=1.0.0
 Requires-Dist: platformdirs
-Requires-Dist: protobuf!=4.21.0,<6,>=3.12.0; python_version < '3.9' and sys_platform == 'linux'
-Requires-Dist: protobuf!=4.21.0,<6,>=3.15.0; python_version == '3.9' and sys_platform == 'linux'
-Requires-Dist: protobuf!=4.21.0,<6,>=3.19.0; python_version > '3.9' and sys_platform == 'linux'
-Requires-Dist: protobuf!=4.21.0,<6,>=3.19.0; sys_platform != 'linux'
+Requires-Dist: protobuf!=4.21.0,!=5.28.0,<6,>=3.12.0; python_version < '3.9' and sys_platform == 'linux'
+Requires-Dist: protobuf!=4.21.0,!=5.28.0,<6,>=3.15.0; python_version == '3.9' and sys_platform == 'linux'
+Requires-Dist: protobuf!=4.21.0,!=5.28.0,<6,>=3.19.0; python_version > '3.9' and sys_platform == 'linux'
+Requires-Dist: protobuf!=4.21.0,!=5.28.0,<6,>=3.19.0; sys_platform != 'linux'
 Requires-Dist: psutil>=5.0.0
 Requires-Dist: pyyaml
 Requires-Dist: requests<3,>=2.0.0
@@ -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'