wandb 0.19.12rc1__py3-none-win32.whl → 0.20.1__py3-none-win32.whl

wandb/sdk/lib/gitlib.py

@@ -51,12 +51,12 @@ class GitRepo:
             return Repo(self._root or os.getcwd(), search_parent_directories=True)
         except FileNotFoundError:
             wandb.termwarn("current working directory has been invalidated")
-            logger.warn("current working directory has been invalidated")
+            logger.warning("current working directory has been invalidated")
         except InvalidGitRepositoryError:
             logger.debug("git repository is invalid")
         except NoSuchPathError:
             wandb.termwarn(f"git root {self._root} does not exist")
-            logger.warn(f"git root {self._root} does not exist")
+            logger.warning(f"git root {self._root} does not exist")
         return None
 
     @property
@@ -87,9 +87,9 @@ class GitRepo:
             return None
         try:
             return self.repo.git.rev_parse("--show-toplevel")
-        except GitCommandError as e:
+        except GitCommandError:
             # todo: collect telemetry on this
-            logger.error(f"git root error: {e}")
+            logger.exception("git root error")
             return None
 
     @property
@@ -214,12 +214,13 @@ class GitRepo:
                         most_recent_ancestor = ancestor
                     elif self.repo.is_ancestor(most_recent_ancestor, ancestor):  # type: ignore
                         most_recent_ancestor = ancestor
-            return most_recent_ancestor
         except GitCommandError as e:
             logger.debug("git remote upstream fork point could not be found")
             logger.debug(str(e))
             return None
 
+        return most_recent_ancestor
+
     def tag(self, name: str, message: Optional[str]) -> Any:
         if not self.repo:
             return None

wandb/sdk/lib/ipython.py

@@ -95,9 +95,9 @@ class ProgressWidget:
             if not self._displayed:
                 self._displayed = True
                 self._ipython_display.display(self._widget)
-        except Exception as e:
+        except Exception:
+            logger.exception("Error in ProgressWidget.update()")
             self._disabled = True
-            logger.exception(e)
             wandb.termwarn(
                 "Unable to render progress bar, see the user log for details"
             )

wandb/sdk/lib/json_util.py

@@ -25,8 +25,8 @@ try:
                 encoded = orjson.dumps(
                     obj, option=orjson.OPT_NON_STR_KEYS, **_kwargs
                 ).decode()
-            except Exception as e:
-                logger.exception(f"Error using orjson.dumps: {e}")
+            except Exception:
+                logger.exception("Error using orjson.dumps")
                 if cls:
                     kwargs["cls"] = cls
                 encoded = json.dumps(obj, **kwargs)
@@ -42,8 +42,8 @@ try:
                     _kwargs["default"] = cls.default
                 encoded = orjson.dumps(obj, option=orjson.OPT_NON_STR_KEYS, **_kwargs)
                 fp.write(encoded)
-            except Exception as e:
-                logger.exception(f"Error using orjson.dump: {e}")
+            except Exception:
+                logger.exception("Error using orjson.dump")
                 if cls:
                     kwargs["cls"] = cls
                 json.dump(obj, fp, **kwargs)
@@ -52,8 +52,8 @@ try:
             """Wrapper for orjson.loads."""
             try:
                 decoded = orjson.loads(obj)
-            except Exception as e:
-                logger.exception(f"Error using orjson.loads: {e}")
+            except Exception:
+                logger.exception("Error using orjson.loads")
                 decoded = json.loads(obj)
 
             return decoded
@@ -62,19 +62,14 @@ try:
             """Wrapper for orjson.load."""
             try:
                 decoded = orjson.loads(fp.read())
-            except Exception as e:
-                logger.exception(f"Error using orjson.load: {e}")
+            except Exception:
+                logger.exception("Error using orjson.load")
                 decoded = json.load(fp)
 
             return decoded
 
     else:
-        from json import (  # type: ignore[assignment] # noqa: F401
-            dump,
-            dumps,
-            load,
-            loads,
-        )
+        from json import dump, dumps, load, loads  # type: ignore[assignment]
 
 except ImportError:
     from json import dump, dumps, load, loads  # type: ignore[assignment] # noqa: F401

wandb/sdk/lib/printer.py

@@ -9,16 +9,11 @@ import platform
 import sys
 from typing import Callable, Iterator
 
-import wandb.util
-
-if sys.version_info >= (3, 12):
-    from typing import override
-else:
-    from typing_extensions import override
-
 import click
+from typing_extensions import override
 
 import wandb
+import wandb.util
 from wandb.errors import term
 from wandb.sdk import wandb_setup
 
@@ -107,7 +102,7 @@ def new_printer(settings: wandb.Settings | None = None) -> Printer:
             has been called, then global settings are used. Otherwise,
             settings (such as silent mode) are ignored.
     """
-    if not settings and (singleton := wandb_setup.singleton()):
+    if not settings and (singleton := wandb_setup.singleton_if_setup()):
         settings = singleton.settings
 
     if ipython.in_jupyter():

wandb/sdk/lib/redirect.py

@@ -510,7 +510,7 @@ class RedirectBase:
 
     @property
     def src_stream(self):
-        return getattr(sys, "__{}__".format(self.src))
+        return getattr(sys, f"__{self.src}__")
 
     @property
     def src_fd(self):

wandb/sdk/lib/retry.py

@@ -94,7 +94,7 @@ class Retry(Generic[_R]):
         """The number of iterations the previous __call__ retried."""
         return self._num_iter
 
-    def __call__(self, *args: Any, **kwargs: Any) -> _R:  # noqa: C901
+    def __call__(self, *args: Any, **kwargs: Any) -> _R:
         """Call the wrapped function, with retries.
 
         Args:
@@ -140,9 +140,7 @@ class Retry(Generic[_R]):
                     if self.retry_callback:
                         self.retry_callback(
                             200,
-                            "{} resolved after {}, resuming normal operation.".format(
-                                self._error_prefix, NOW_FN() - start_time
-                            ),
+                            f"{self._error_prefix} resolved after {NOW_FN() - start_time}, resuming normal operation.",
                         )
                 return result
             except self._retryable_exceptions as e:
@@ -184,9 +182,7 @@ class Retry(Generic[_R]):
                         # but some of these can be raised before the retry handler thread (RunStatusChecker) is
                         # spawned in wandb_init
                         wandb.termlog(
-                            "{} ({}), entering retry loop.".format(
-                                self._error_prefix, e.__class__.__name__
-                            )
+                            f"{self._error_prefix} ({e.__class__.__name__}), entering retry loop."
                         )
                 # if wandb.env.is_debug():
                 #     traceback.print_exc()

wandb/sdk/lib/run_moment.py

@@ -33,11 +33,11 @@ class RunMoment:
                 f"Only the metric '_step' is supported, got '{self.metric}'."
             )
         if not isinstance(self.value, (int, float)):
-            raise ValueError(
+            raise TypeError(
                 f"Only int or float values are supported, got '{self.value}'."
             )
         if not isinstance(self.run, str):
-            raise ValueError(f"Only string run names are supported, got '{self.run}'.")
+            raise TypeError(f"Only string run names are supported, got '{self.run}'.")
 
     @classmethod
     def from_uri(cls, uri: str) -> RunMoment:

wandb/sdk/lib/service_connection.py

@@ -167,7 +167,6 @@ class ServiceConnection:
             handle = self._mailbox.require_response(request)
             self._client.send_server_request(request)
             response = handle.wait_or(timeout=10)
-            return response.inform_attach_response.settings
 
         except (MailboxClosedError, HandleAbandonedError, SockClientClosedError):
             raise WandbAttachFailedError(
@@ -181,6 +180,9 @@ class ServiceConnection:
                 " process is busy (unlikely)."
             ) from None
 
+        else:
+            return response.inform_attach_response.settings
+
     def inform_start(
         self,
         settings: wandb_settings_pb2.Settings,

wandb/sdk/lib/service_token.py

@@ -31,8 +31,7 @@ def get_service_token() -> ServiceToken | None:
 
     if version != _CURRENT_VERSION:
         raise ValueError(
-            f"Expected version {_CURRENT_VERSION},"
-            f" but got {version} (token={token})"
+            f"Expected version {_CURRENT_VERSION}, but got {version} (token={token})"
         )
     if transport not in _SUPPORTED_TRANSPORTS:
         raise ValueError(

wandb/sdk/mailbox/mailbox_handle.py

@@ -1,18 +1,14 @@
 from __future__ import annotations
 
 import abc
-import sys
-from typing import TYPE_CHECKING, Callable, Generic, TypeVar
+from typing import TYPE_CHECKING, Callable, Generic
+
+from typing_extensions import TypeVar, override
 
 # Necessary to break an import loop.
 if TYPE_CHECKING:
     from wandb.sdk.interface import interface
 
-if sys.version_info >= (3, 12):
-    from typing import override
-else:
-    from typing_extensions import override
-
 
 _T = TypeVar("_T")
 _S = TypeVar("_S")

wandb/sdk/mailbox/response_handle.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import asyncio
 import math
-import sys
 import threading
 from typing import TYPE_CHECKING
 
+from typing_extensions import override
+
 from wandb.proto import wandb_server_pb2 as spb
 
 from .mailbox_handle import HandleAbandonedError, MailboxHandle
@@ -14,11 +15,6 @@ from .mailbox_handle import HandleAbandonedError, MailboxHandle
 if TYPE_CHECKING:
     from wandb.sdk.interface import interface
 
-if sys.version_info >= (3, 12):
-    from typing import override
-else:
-    from typing_extensions import override
-
 
 class MailboxResponseHandle(MailboxHandle[spb.ServerResponse]):
     """A general handle for any ServerResponse."""

wandb/sdk/service/streams.py

@@ -18,11 +18,10 @@ from typing import Any, Callable, NoReturn
 
 import psutil
 
-import wandb
-import wandb.util
 from wandb.proto import wandb_internal_pb2 as pb
 from wandb.sdk.interface.interface_relay import InterfaceRelay
 from wandb.sdk.interface.router_relay import MessageRelayRouter
+from wandb.sdk.internal.internal import wandb_internal
 from wandb.sdk.internal.settings_static import SettingsStatic
 from wandb.sdk.lib import asyncio_compat, progress
 from wandb.sdk.lib import printer as printerlib
@@ -212,7 +211,7 @@ class StreamMux:
         # run_id = action.stream_id  # will want to fix if a streamid != runid
         settings = action._data
         thread = StreamThread(
-            target=wandb.wandb_sdk.internal.internal.wandb_internal,  # type: ignore
+            target=wandb_internal,
             kwargs=dict(
                 settings=settings,
                 record_q=stream._record_q,
@@ -420,10 +419,7 @@ class StreamMux:
         self._action_q.join()
 
     def loop(self) -> None:
-        try:
-            self._loop()
-        except Exception as e:
-            raise e
+        self._loop()
 
     def cleanup(self) -> None:
         pass

wandb/sdk/verify/verify.py

@@ -474,13 +474,12 @@ def check_wandb_version(api: Api) -> None:
     min_cli_version = server_info.get("cliVersionInfo", {}).get(
         "min_cli_version", "0.0.1"
     )
-    from wandb.util import parse_version
 
-    if parse_version(wandb.__version__) < parse_version(min_cli_version):
-        fail_string = "wandb version out of date, please run pip install --upgrade wandb=={}".format(
-            max_cli_version
-        )
-    elif parse_version(wandb.__version__) > parse_version(max_cli_version):
+    from packaging.version import parse
+
+    if parse(wandb.__version__) < parse(min_cli_version):
+        fail_string = f"wandb version out of date, please run pip install --upgrade wandb=={max_cli_version}"
+    elif parse(wandb.__version__) > parse(max_cli_version):
         fail_string = (
             "wandb version is not supported by your local installation. This could "
             "cause some issues. If you're having problems try: please run `pip "

wandb/sdk/wandb_config.py

@@ -272,7 +272,7 @@ class Config:
         # TODO: enable WBValues in the config in the future
         # refuse all WBValues which is all Media and Histograms
         if isinstance(val, wandb.sdk.data_types.base_types.wb_value.WBValue):
-            raise ValueError("WBValue objects cannot be added to the run config")
+            raise TypeError("WBValue objects cannot be added to the run config")
         # Let jupyter change config freely by default
         if self._settings and self._settings._jupyter and allow_val_change is None:
             allow_val_change = True

wandb/sdk/wandb_init.py

@@ -21,12 +21,9 @@ import platform
 import sys
 import tempfile
 import time
-from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, Protocol, Sequence
+from typing import TYPE_CHECKING, Iterable, Iterator, Sequence
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from typing_extensions import Any, Literal, Protocol, Self
 
 import wandb
 import wandb.env
@@ -62,20 +59,6 @@ def _huggingface_version() -> str | None:
     return None
 
 
-def _maybe_mp_process(backend: Backend) -> bool:
-    parent_process = getattr(
-        backend._multiprocessing, "parent_process", None
-    )  # New in version 3.8.
-    if parent_process:
-        return parent_process() is not None
-    process = backend._multiprocessing.current_process()
-    if process.name == "MainProcess":
-        return False
-    if process.name.startswith("Process-"):
-        return True
-    return False
-
-
 def _handle_launch_config(settings: Settings) -> dict[str, Any]:
     launch_run_config: dict[str, Any] = {}
     if not settings.launch:
@@ -219,15 +202,11 @@ class _WandbInit:
         Returns:
             A callback to print any generated warnings.
         """
-        singleton = wandb_setup.singleton()
-        if singleton is None:
-            return _noop_printer_callback()
-
         exclude_env_vars = {"WANDB_SERVICE", "WANDB_KUBEFLOW_URL"}
         # check if environment variables have changed
         singleton_env = {
             k: v
-            for k, v in singleton._environ.items()
+            for k, v in wandb_setup.singleton()._environ.items()
             if k.startswith("WANDB_") and k not in exclude_env_vars
         }
         os_env = {
@@ -381,7 +360,7 @@ class _WandbInit:
                 return None
 
             except KeyError:
-                self._logger.error(
+                self._logger.exception(
                     f"resume file at {resume_file} did not store a run_id"
                 )
                 return None
@@ -892,15 +871,12 @@ class _WandbInit:
 
         self._logger.info("starting backend")
 
-        if not settings.x_disable_service:
-            service = self._wl.ensure_service()
-            self._logger.info("sending inform_init request")
-            service.inform_init(
-                settings=settings.to_proto(),
-                run_id=settings.run_id,  # type: ignore
-            )
-        else:
-            service = None
+        service = self._wl.ensure_service()
+        self._logger.info("sending inform_init request")
+        service.inform_init(
+            settings=settings.to_proto(),
+            run_id=settings.run_id,  # type: ignore
+        )
 
         backend = Backend(settings=settings, service=service)
         backend.ensure_launched()
@@ -939,35 +915,12 @@ class _WandbInit:
             for module_name in telemetry.list_telemetry_imports(only_imported=True):
                 setattr(tel.imports_init, module_name, True)
 
-            # probe the active start method
-            active_start_method: str | None = None
-            if settings.start_method == "thread":
-                active_start_method = settings.start_method
-            else:
-                active_start_method = getattr(
-                    backend._multiprocessing, "get_start_method", lambda: None
-                )()
-
-            if active_start_method == "spawn":
-                tel.env.start_spawn = True
-            elif active_start_method == "fork":
-                tel.env.start_fork = True
-            elif active_start_method == "forkserver":
-                tel.env.start_forkserver = True
-            elif active_start_method == "thread":
-                tel.env.start_thread = True
-
             if os.environ.get("PEX"):
                 tel.env.pex = True
 
             if settings._aws_lambda:
                 tel.env.aws_lambda = True
 
-            if os.environ.get(wandb.env._DISABLE_SERVICE):
-                tel.feature.service_disabled = True
-
-            if service:
-                tel.feature.service = True
             if settings.x_flow_control_disabled:
                 tel.feature.flow_control_disabled = True
             if settings.x_flow_control_custom:
@@ -987,8 +940,6 @@ class _WandbInit:
             if wandb.env.dcgm_profiling_enabled():
                 tel.feature.dcgm_profiling_enabled = True
 
-            tel.env.maybe_mp = _maybe_mp_process(backend)
-
         if not settings.label_disable:
             if self.notebook:
                 run._label_probe_notebook(self.notebook)
@@ -1044,56 +995,33 @@ class _WandbInit:
                     backend.interface,
                 )
 
-        # Raise an error if deliver_run failed.
-        #
-        # This is wrapped in a try-except to perform additional cleanup logic
-        # when x_disable_service is True.
-        #
-        # TODO: Remove try-except once x_disable_service is removed.
         try:
-            try:
-                result = wait_with_progress(
-                    run_init_handle,
-                    timeout=timeout,
-                    progress_after=1,
-                    display_progress=display_init_message,
-                )
-
-            except TimeoutError:
-                run_init_handle.cancel(backend.interface)
-
-                # This may either be an issue with the W&B server (a CommError)
-                # or a bug in the SDK (an Error). We cannot distinguish between
-                # the two causes here.
-                raise CommError(
-                    f"Run initialization has timed out after {timeout} sec."
-                    " Please try increasing the timeout with the `init_timeout`"
-                    " setting: `wandb.init(settings=wandb.Settings(init_timeout=120))`."
-                )
+            result = wait_with_progress(
+                run_init_handle,
+                timeout=timeout,
+                progress_after=1,
+                display_progress=display_init_message,
+            )
 
-            assert result.run_result
+        except TimeoutError:
+            run_init_handle.cancel(backend.interface)
+
+            # This may either be an issue with the W&B server (a CommError)
+            # or a bug in the SDK (an Error). We cannot distinguish between
+            # the two causes here.
+            raise CommError(
+                f"Run initialization has timed out after {timeout} sec."
+                " Please try increasing the timeout with the `init_timeout`"
+                " setting: `wandb.init(settings=wandb.Settings(init_timeout=120))`."
+            )
 
-            if error := ProtobufErrorHandler.to_exception(result.run_result.error):
-                raise error
+        assert result.run_result
 
-            if not result.run_result.HasField("run"):
-                raise Error("Assertion failed: run_result is missing the run field")
+        if error := ProtobufErrorHandler.to_exception(result.run_result.error):
+            raise error
 
-        except Exception:
-            if not service:
-                # Kill the background thread or process.
-                backend.cleanup()
-
-                # Do some Jupyter and logger cleanup.
-                #
-                # NOTE: This shouldn't be necessary. The logger is global,
-                #   so on any error outside of this try-catch, we fail to
-                #   clean it up, causing the next run to write some of its
-                #   initial logs to this run's log file. The Jupyter
-                #   monkeypatching should probably happen at the library level
-                #   (in wandb.setup()) rather than per-run.
-                self.teardown()
-            raise
+        if not result.run_result.HasField("run"):
+            raise Error("Assertion failed: run_result is missing the run field")
 
         if result.run_result.run.resumed:
             self._logger.info("run resumed")
@@ -1177,7 +1105,7 @@ def _attach(
         )
     wandb._assert_is_user_process()  # type: ignore
 
-    _wl = wandb.setup()
+    _wl = wandb_setup.singleton()
     logger = _wl._get_logger()
 
     service = _wl.ensure_service()
@@ -1616,7 +1544,7 @@ def init(  # noqa: C901
     wl: wandb_setup._WandbSetup | None = None
 
     try:
-        wl = wandb_setup._setup(start_service=False)
+        wl = wandb_setup.singleton()
 
         wi = _WandbInit(wl, init_telemetry)
 
@@ -1637,6 +1565,10 @@ def init(  # noqa: C901
             init_telemetry.feature.set_init_tags = True
         if run_settings._offline:
             init_telemetry.feature.offline = True
+        if run_settings.fork_from is not None:
+            init_telemetry.feature.fork_mode = True
+        if run_settings.resume_from is not None:
+            init_telemetry.feature.rewind_mode = True
 
         wi.set_run_id(run_settings)
         run_printer = printer.new_printer(run_settings)

wandb/sdk/wandb_login.py

@@ -13,6 +13,7 @@ from requests.exceptions import ConnectionError
 import wandb
 from wandb.errors import AuthenticationError, UsageError
 from wandb.old.settings import Settings as OldSettings
+from wandb.sdk import wandb_setup
 
 from ..apis import InternalApi
 from .internal.internal_api import Api
@@ -115,7 +116,7 @@ class _WandbLogin:
         }
         self.is_anonymous = anonymous == "must"
 
-        self._wandb_setup = wandb.setup()
+        self._wandb_setup = wandb_setup.singleton()
         self._wandb_setup.settings.update_from_dict(login_settings)
         self._settings = self._wandb_setup.settings
 
@@ -248,11 +249,6 @@ class _WandbLogin:
 
         try:
             is_api_key_valid = api.validate_api_key()
-
-            if not is_api_key_valid:
-                raise AuthenticationError(
-                    "API key verification failed. Make sure your API key is valid."
-                )
         except ConnectionError:
             raise AuthenticationError(
                 "Unable to connect to server to verify API token."
@@ -260,6 +256,11 @@ class _WandbLogin:
         except Exception:
             raise AuthenticationError("An error occurred while verifying the API key.")
 
+        if not is_api_key_valid:
+            raise AuthenticationError(
+                "API key verification failed. Make sure your API key is valid."
+            )
+
 
 def _login(
     *,