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

wandb/sdk/data_types/trace_tree.py

@@ -14,9 +14,9 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 import wandb
-import wandb.data_types
 from wandb.sdk.data_types import _dtypes
 from wandb.sdk.data_types.base_types.media import Media
+from wandb.sdk.data_types.utils import _json_helper
 
 if TYPE_CHECKING:  # pragma: no cover
     from wandb.sdk.artifacts.artifact import Artifact
@@ -142,7 +142,7 @@ def _fallback_serialize(obj: Any) -> str:
 def _safe_serialize(obj: dict) -> str:
     try:
         return json.dumps(
-            wandb.data_types._json_helper(obj, None),
+            _json_helper(obj, None),
             skipkeys=True,
             default=_fallback_serialize,
         )

wandb/sdk/data_types/utils.py

@@ -1,6 +1,8 @@
+import datetime
 import logging
 import os
 import re
+from decimal import Decimal
 from typing import TYPE_CHECKING, Optional, Sequence, Union, cast
 
 import wandb
@@ -178,3 +180,50 @@ def _prune_max_seq(seq: Sequence["BatchableMedia"]) -> Sequence["BatchableMedia"
         )
         items = seq[: seq[0].MAX_ITEMS]
     return items
+
+
+def _json_helper(val, artifact):
+    if isinstance(val, WBValue):
+        return val.to_json(artifact)
+    elif val.__class__ is dict:
+        res = {}
+        for key in val:
+            res[key] = _json_helper(val[key], artifact)
+        return res
+
+    if hasattr(val, "tolist"):
+        py_val = val.tolist()
+        if val.__class__.__name__ == "datetime64" and isinstance(py_val, int):
+            # when numpy datetime64 .tolist() returns an int, it is nanoseconds.
+            # need to convert to milliseconds
+            return _json_helper(py_val / int(1e6), artifact)
+        return _json_helper(py_val, artifact)
+    elif hasattr(val, "item"):
+        return _json_helper(val.item(), artifact)
+
+    if isinstance(val, datetime.datetime):
+        if val.tzinfo is None:
+            val = datetime.datetime(
+                val.year,
+                val.month,
+                val.day,
+                val.hour,
+                val.minute,
+                val.second,
+                val.microsecond,
+                tzinfo=datetime.timezone.utc,
+            )
+        return int(val.timestamp() * 1000)
+    elif isinstance(val, datetime.date):
+        return int(
+            datetime.datetime(
+                val.year, val.month, val.day, tzinfo=datetime.timezone.utc
+            ).timestamp()
+            * 1000
+        )
+    elif isinstance(val, (list, tuple)):
+        return [_json_helper(i, artifact) for i in val]
+    elif isinstance(val, Decimal):
+        return float(val)
+    else:
+        return util.json_friendly(val)[0]

wandb/sdk/service/service.py

@@ -15,11 +15,7 @@ import time
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from wandb import _sentry, termlog
-from wandb.env import (
-    core_debug,
-    core_error_reporting_enabled,
-    is_require_legacy_service,
-)
+from wandb.env import core_debug, error_reporting_enabled, is_require_legacy_service
 from wandb.errors import Error, WandbCoreNotAvailableError
 from wandb.sdk.lib.wburls import wburls
 from wandb.util import get_core_path, get_module
@@ -162,9 +158,6 @@ class _Service:
 
             executable = self._settings._executable
             exec_cmd_list = [executable, "-m"]
-            # Add coverage collection if needed
-            if os.environ.get("YEA_RUN_COVERAGE") and os.environ.get("COVERAGE_RCFILE"):
-                exec_cmd_list += ["coverage", "run", "-m"]
 
             service_args = []
 
@@ -176,7 +169,7 @@ class _Service:
 
                 service_args.extend([core_path])
 
-                if not core_error_reporting_enabled(default="True"):
+                if not error_reporting_enabled():
                     service_args.append("--no-observability")
 
                 if core_debug(default="False"):

wandb/sdk/service/streams.py

@@ -317,7 +317,6 @@ class StreamMux:
         # These could be done in parallel in the future
         for _sid, stream in started_streams.items():
             # dispatch all our final requests
-            server_info_handle = stream.interface.deliver_request_server_info()
             poll_exit_handle = stream.interface.deliver_poll_exit()
             final_summary_handle = stream.interface.deliver_get_summary()
             sampled_history_handle = stream.interface.deliver_request_sampled_history()
@@ -327,11 +326,6 @@ class StreamMux:
             assert result
             internal_messages_response = result.response.internal_messages_response
 
-            # wait for them, it's ok to do this serially but this can be improved
-            result = server_info_handle.wait(timeout=-1)
-            assert result
-            server_info_response = result.response.server_info_response
-
             result = poll_exit_handle.wait(timeout=-1)
             assert result
             poll_exit_response = result.response.poll_exit_response
@@ -348,7 +342,6 @@ class StreamMux:
                 sampled_history=sampled_history,
                 final_summary=final_summary,
                 poll_exit_response=poll_exit_response,
-                server_info_response=server_info_response,
                 internal_messages_response=internal_messages_response,
                 settings=stream._settings,  # type: ignore
                 printer=printer,

wandb/sdk/wandb_init.py

@@ -174,12 +174,19 @@ class _WandbInit:
 
         # we add this logic to be backward compatible with the old behavior of disable
         # where it would disable the service if the mode was set to disabled
+        # TODO: use the regular settins object to handle this
         mode = kwargs.get("mode")
         settings_mode = (kwargs.get("settings") or {}).get("mode") or os.environ.get(
-            "WANDB_MODE"
+            wandb.env.MODE
         )
-        _disable_service = mode == "disabled" or settings_mode == "disabled"
-        setup_settings = {"_disable_service": _disable_service}
+        settings__disable_service = (kwargs.get("settings") or {}).get(
+            "_disable_service"
+        ) or os.environ.get(wandb.env._DISABLE_SERVICE)
+
+        setup_settings = {
+            "mode": mode or settings_mode,
+            "_disable_service": settings__disable_service,
+        }
 
         self._wl = wandb_setup.setup(settings=setup_settings)
         # Make sure we have a logger setup (might be an early logger)

wandb/sdk/wandb_run.py

@@ -43,12 +43,12 @@ 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.proto.wandb_internal_pb2 import (
     MetricRecord,
     PollExitResponse,
     Result,
     RunRecord,
-    ServerInfoResponse,
 )
 from wandb.sdk.artifacts.artifact import Artifact
 from wandb.sdk.internal import job_builder
@@ -62,7 +62,7 @@ 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]
@@ -624,7 +621,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 +666,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 +922,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 +1147,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,
@@ -2453,8 +2448,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,
@@ -2676,25 +2669,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 +3686,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 +3799,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 +3821,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 +3835,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 +4089,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 +4106,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_setup.py

@@ -281,7 +281,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             sys.exit(internal_exit_code)
 
     def _setup_manager(self) -> None:
-        if self._settings._disable_service:
+        if self._settings._noop or self._settings._disable_service:
             return
         self._manager = wandb_manager._Manager(settings=self._settings)
 

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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.18.0
+Version: 0.18.1
 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