wandb 0.13.10__py3-none-any.whl → 0.14.0__py3-none-any.whl

wandb/sdk/wandb_config.py

@@ -1,6 +1,4 @@
-"""
-config.
-"""
+"""config."""
 
 import logging
 from typing import Optional
@@ -22,8 +20,7 @@ logger = logging.getLogger("wandb")
 # if this is done right we might make sure this is pickle-able
 # we might be able to do this on other objects like Run?
 class Config:
-    """
-    Config object
+    """Config object.
 
     Config objects are intended to hold all of the hyperparameters associated with
     a wandb run and are saved with the run object when `wandb.init` is called.
@@ -32,11 +29,11 @@ class Config:
     setting the config as a parameter to init, ie. `wandb.init(config=my_config_dict)`
 
     You can create a file called `config-defaults.yaml`, and it will automatically be
-    loaded into `wandb.config`. See https://docs.wandb.com/library/config#file-based-configs.
+    loaded into `wandb.config`. See https://docs.wandb.com/guides/track/config#file-based-configs.
 
     You can also load a config YAML file with your custom name and pass the filename
     into `wandb.init(config="special_config.yaml")`.
-    See https://docs.wandb.com/library/config#file-based-configs.
+    See https://docs.wandb.com/guides/track/config#file-based-configs.
 
     Examples:
         Basic usage
@@ -193,7 +190,7 @@ class Config:
         return self._items.get(*args)
 
     def persist(self):
-        """Calls the callback if it's set"""
+        """Call the callback if it's set."""
         if self._callback:
             self._callback(data=self._as_dict())
 

wandb/sdk/wandb_helper.py

@@ -29,7 +29,7 @@ def _to_dict(params):
     if meta:
         is_tf_flags_module = (
             isinstance(params, types.ModuleType)
-            and meta.__name__ == "tensorflow.python.platform.flags"  # noqa: W503
+            and meta.__name__ == "tensorflow.python.platform.flags"
         )
         if is_tf_flags_module or meta.__name__ == "absl.flags":
             params = params.FLAGS

wandb/sdk/wandb_init.py

@@ -124,7 +124,7 @@ class _WandbInit:
         self.printer = get_printer(settings._jupyter)
 
     def setup(self, kwargs: Any) -> None:  # noqa: C901
-        """Completes setup for `wandb.init()`.
+        """Complete setup for `wandb.init()`.
 
         This includes parsing all arguments, applying them with settings and enabling logging.
         """
@@ -161,13 +161,27 @@ class _WandbInit:
                 )
                 self.printer.display(line, level="warn")
 
-        self._wl = wandb_setup.setup()
+        # 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
+        mode = kwargs.get("mode")
+        settings_mode = (kwargs.get("settings") or {}).get("mode")
+        _disable_service = mode == "disabled" or settings_mode == "disabled"
+        setup_settings = {"_disable_service": _disable_service}
+
+        self._wl = wandb_setup.setup(settings=setup_settings)
         # Make sure we have a logger setup (might be an early logger)
         assert self._wl is not None
         _set_logger(self._wl._get_logger())
 
         # Start with settings from wandb library singleton
         settings: Settings = self._wl.settings.copy()
+
+        # when using launch, we don't want to reuse the same run id from the singleton
+        # since users might launch multiple runs in the same process
+        # TODO(kdg): allow users to control this via launch settings
+        if settings.launch and singleton is not None:
+            settings.update({"run_id": None}, source=Source.INIT)
+
         settings_param = kwargs.pop("settings", None)
         if settings_param is not None and isinstance(settings_param, (Settings, dict)):
             settings.update(settings_param, source=Source.INIT)
@@ -329,7 +343,7 @@ class _WandbInit:
                 config_target.setdefault(k, v)
 
     def _enable_logging(self, log_fname: str, run_id: Optional[str] = None) -> None:
-        """Enables logging to the global debug log.
+        """Enable logging to the global debug log.
 
         This adds a run_id to the log, in case of multiple processes on the same machine.
         Currently, there is no way to disable logging after it's enabled.
@@ -455,7 +469,7 @@ class _WandbInit:
         ipython.display_pub.publish = publish
 
     def _log_setup(self, settings: Settings) -> None:
-        """Sets up logging from settings."""
+        """Set up logging from settings."""
         filesystem.mkdir_exists_ok(os.path.dirname(settings.log_user))
         filesystem.mkdir_exists_ok(os.path.dirname(settings.log_internal))
         filesystem.mkdir_exists_ok(os.path.dirname(settings.sync_file))
@@ -547,7 +561,7 @@ class _WandbInit:
                 if len(self._wl._global_run_stack) > 1:
                     wandb.termwarn(
                         "If you want to track multiple runs concurrently in wandb, "
-                        "you should use multi-processing not threads"  # noqa: E501
+                        "you should use multi-processing not threads"
                     )
 
                 last_id = self._wl._global_run_stack[-1]._run_id
@@ -929,7 +943,7 @@ def init(
     id: Optional[str] = None,
     settings: Union[Settings, Dict[str, Any], None] = None,
 ) -> Union[Run, RunDisabled, None]:
-    r"""Starts a new run to track and log to W&B.
+    r"""Start a new run to track and log to W&B.
 
     In an ML training pipeline, you could add `wandb.init()`
     to the beginning of your training script as well as your evaluation
@@ -1000,7 +1014,7 @@ def init(
             a model against different test sets. Group gives you a way to
             organize runs together into a larger whole, and you can toggle this
             on and off in the UI. For more details, see our
-            [guide to grouping runs](https://docs.wandb.com/library/grouping).
+            [guide to grouping runs](https://docs.wandb.com/guides/runs/grouping).
         job_type: (str, optional) Specify the type of run, which is useful when
             you're grouping runs together into larger experiments using group.
             For example, you might have multiple jobs in a group, with job types
@@ -1042,7 +1056,7 @@ def init(
                 `WANDB_RUN_ID="UNIQUE_ID"` and it is identical to a previous run,
                 wandb will automatically resume the run with the id. Otherwise,
                 wandb will crash.
-            See [our guide to resuming runs](https://docs.wandb.com/library/advanced/resuming)
+            See [our guide to resuming runs](https://docs.wandb.com/guides/runs/resuming)
             for more.
         reinit: (bool, optional) Allow multiple `wandb.init()` calls in the same
             process. (default: `False`)
@@ -1077,13 +1091,13 @@ def init(
             tensorboardX and save the relevant events file. (default: `False`)
         monitor_gym: (bool, optional) Automatically log videos of environment when
             using OpenAI Gym. (default: `False`)
-            See [our guide to this integration](https://docs.wandb.com/library/integrations/openai-gym).
+            See [our guide to this integration](https://docs.wandb.com/guides/integrations/openai-gym).
         id: (str, optional) A unique ID for this run, used for resuming. It must
             be unique in the project, and if you delete a run you can't reuse
             the ID. Use the `name` field for a short descriptive name, or `config`
             for saving hyperparameters to compare across runs. The ID cannot
             contain the following special characters: `/\#?%:`.
-            See [our guide to resuming runs](https://docs.wandb.com/library/resuming).
+            See [our guide to resuming runs](https://docs.wandb.com/guides/runs/resuming).
 
     Examples:
     ### Set where the run is logged
@@ -1113,9 +1127,6 @@ def init(
     wandb.init(config=config)
     ```
 
-    Raises:
-        Exception: if problem.
-
     Returns:
         A `Run` object.
     """

wandb/sdk/wandb_login.py

@@ -1,6 +1,6 @@
-"""
-Log in to Weights & Biases, authenticating your machine to log data to your
-account.
+"""Log in to Weights & Biases.
+
+This authenticates your machine to log data to your account.
 """
 
 import enum
@@ -26,9 +26,11 @@ from .wandb_settings import Settings, Source
 
 
 def _handle_host_wandb_setting(host: Optional[str], cloud: bool = False) -> None:
-    """Write the host parameter from wandb.login or wandb login to
-    the global settings file so that it is used automatically by
-    the application's APIs."""
+    """Write the host parameter to the global settings file.
+
+    This takes the parameter from wandb.login or wandb login for use by the
+    application's APIs.
+    """
     _api = InternalApi()
     if host == "https://api.wandb.ai" or (host is None and cloud):
         _api.clear_setting("base_url", globally=True, persist=True)
@@ -49,8 +51,7 @@ def login(
     force: Optional[bool] = None,
     timeout: Optional[int] = None,
 ) -> bool:
-    """
-    Log in to W&B.
+    """Log in to W&B.
 
     Arguments:
         anonymous: (string, optional) Can be "must", "allow", or "never".
@@ -69,7 +70,6 @@ def login(
     Raises:
         UsageError - if api_key cannot be configured and no tty
     """
-
     _handle_host_wandb_setting(host)
     if wandb.setup()._settings._noop:
         return True

wandb/sdk/wandb_manager.py

@@ -7,11 +7,15 @@ import atexit
 import os
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
 
+import psutil
+
 import wandb
 from wandb import env, trigger
+from wandb.errors import Error
 from wandb.sdk.lib.exit_hooks import ExitHooks
 from wandb.sdk.lib.import_hooks import unregister_all_post_import_hooks
 from wandb.sdk.lib.proto_util import settings_dict_from_pbmap
+from wandb.util import sentry_reraise
 
 if TYPE_CHECKING:
     from wandb.sdk.service import service
@@ -19,6 +23,18 @@ if TYPE_CHECKING:
     from wandb.sdk.wandb_settings import Settings
 
 
+class ManagerConnectionError(Error):
+    """Raised when service process is not running."""
+
+    pass
+
+
+class ManagerConnectionRefusedError(ManagerConnectionError):
+    """Raised when service process is not running."""
+
+    pass
+
+
 class _ManagerToken:
     _version = "2"
     _supported_transports = {"grpc", "tcp"}
@@ -93,8 +109,26 @@ class _Manager:
     _settings: "Settings"
     _service: "service._Service"
 
+    def _service_connect(self) -> None:
+        port = self._token.port
+        svc_iface = self._get_service_interface()
+
+        try:
+            svc_iface._svc_connect(port=port)
+        except ConnectionRefusedError as e:
+            if not psutil.pid_exists(self._token.pid):
+                message = (
+                    "Connection to wandb service failed "
+                    "since the process is not available. "
+                )
+            else:
+                message = f"Connection to wandb service failed: {e}. "
+            raise ManagerConnectionRefusedError(message)
+        except Exception as e:
+            raise ManagerConnectionError(f"Connection to wandb service failed: {e}")
+
     def __init__(self, settings: "Settings") -> None:
-        # TODO: warn if user doesnt have grpc installed
+        # TODO: warn if user doesn't have grpc installed
         from wandb.sdk.service import service
 
         self._settings = settings
@@ -124,9 +158,10 @@ class _Manager:
 
         self._token = token
 
-        port = self._token.port
-        svc_iface = self._get_service_interface()
-        svc_iface._svc_connect(port=port)
+        try:
+            self._service_connect()
+        except ManagerConnectionError as e:
+            sentry_reraise(e, delay=True)
 
     def _atexit_setup(self) -> None:
         self._atexit_lambda = lambda: self._atexit_teardown()

wandb/sdk/wandb_metric.py

@@ -1,6 +1,4 @@
-"""
-metric.
-"""
+"""metric."""
 
 import logging
 from typing import Callable, Optional, Sequence, Tuple
@@ -11,9 +9,7 @@ logger = logging.getLogger("wandb")
 
 
 class Metric:
-    """
-    Metric object
-    """
+    """Metric object."""
 
     _callback: Optional[Callable[[pb.MetricRecord], None]]
     _name: str

wandb/sdk/wandb_require.py

@@ -9,12 +9,10 @@ Example:
     wandb.require("incremental-artifacts@beta")
 """
 
-import os
 from typing import Optional, Sequence, Union
 
 import wandb
-from wandb.env import _DISABLE_SERVICE, REQUIRE_SERVICE
-from wandb.errors import RequireError
+from wandb.errors import UnsupportedError
 from wandb.sdk import wandb_run
 from wandb.sdk.lib.wburls import wburls
 
@@ -33,18 +31,11 @@ class _Requires:
         pass
 
     def _require_service(self) -> None:
-        os.environ[REQUIRE_SERVICE] = "True"
         wandb.teardown = wandb._teardown  # type: ignore
         wandb.attach = wandb._attach  # type: ignore
         wandb_run.Run.detach = wandb_run.Run._detach  # type: ignore
 
     def require_service(self) -> None:
-        disable_service = os.environ.get(_DISABLE_SERVICE)
-        if disable_service:
-            if REQUIRE_SERVICE in os.environ:
-                del os.environ[REQUIRE_SERVICE]
-            return
-
         self._require_service()
 
     def apply(self) -> None:
@@ -65,7 +56,7 @@ class _Requires:
             wandb.termerror(
                 f"Supported wandb.require() features can be found at: {wburls.get('doc_require')}"
             )
-            raise RequireError(last_message)
+            raise UnsupportedError(last_message)
 
 
 def require(
@@ -79,7 +70,7 @@ def require(
         experiment: (str or list) Features to require
 
     Raises:
-        wandb.errors.RequireError: if not supported or other error
+        wandb.errors.UnsupportedError: if not supported
     """
     features = requirement or experiment
     if not features:
@@ -93,6 +84,4 @@ def _import_module_hook() -> None:
     """On wandb import, setup anything needed based on parent process require calls."""
     # TODO: optimize by caching which pids this has been done for or use real import hooks
     # TODO: make this more generic, but for now this works
-    req_service = os.environ.get(REQUIRE_SERVICE)
-    if req_service:
-        require("service")
+    require("service")

wandb/sdk/wandb_require_helpers.py

@@ -10,9 +10,7 @@ requirement_env_var_mapping: Dict[str, str] = {
 
 
 def requires(requirement: str) -> FuncT:  # type: ignore
-    """
-    The decorator for gating features.
-    """
+    """Decorate functions to gate features with wandb.require."""
     env_var = requirement_env_var_mapping[requirement]
 
     def deco(func: FuncT) -> FuncT:
@@ -33,15 +31,9 @@ class RequiresMixin:
     requirement = ""
 
     def __init__(self) -> None:
-        """
-        This hook for normal classes
-        """
         self._check_if_requirements_met()
 
     def __post_init__(self) -> None:
-        """
-        This hook added for dataclasses
-        """
         self._check_if_requirements_met()
 
     def _check_if_requirements_met(self) -> None: