wandb 0.18.6__py3-none-any.whl → 0.19.0rc1__py3-none-any.whl

wandb/sdk/wandb_setup.py

@@ -11,43 +11,32 @@ run_id can be resolved.
 
 """
 
+from __future__ import annotations
+
 import logging
 import os
 import sys
 import threading
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import wandb
 from wandb.sdk.lib import import_hooks
 
 from . import wandb_settings
-from .lib import config_util, server, tracelog
-
-Settings = Union["wandb.sdk.wandb_settings.Settings", Dict[str, Any]]
-
-Logger = Union[logging.Logger, "_EarlyLogger"]
+from .lib import config_util, server
 
 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
-logger: Optional[Logger] = None
-
-
-def _set_logger(log_object: Logger) -> None:
-    """Configure module logger."""
-    global logger
-    logger = log_object
+    from wandb.sdk.lib.service_connection import ServiceConnection
+    from wandb.sdk.wandb_run import Run
+    from wandb.sdk.wandb_settings import Settings
 
 
 class _EarlyLogger:
     """Early logger which captures logs in memory until logging can be configured."""
 
     def __init__(self) -> None:
-        self._log: List[tuple] = []
-        self._exception: List[tuple] = []
+        self._log: list[tuple] = []
+        self._exception: list[tuple] = []
         # support old warn() as alias of warning()
         self.warn = self.warning
 
@@ -81,25 +70,37 @@ class _EarlyLogger:
             logger.exception(msg, *args, **kwargs)
 
 
+Logger = Union[logging.Logger, _EarlyLogger]
+
+# logger will be configured to be either a standard logger instance or _EarlyLogger
+logger: Logger | None = None
+
+
+def _set_logger(log_object: Logger) -> None:
+    """Configure module logger."""
+    global logger
+    logger = log_object
+
+
 class _WandbSetup__WandbSetup:  # noqa: N801
     """Inner class of _WandbSetup."""
 
     def __init__(
         self,
         pid: int,
-        settings: Optional[Settings] = None,
-        environ: Optional[Dict[str, Any]] = None,
+        settings: Settings | None = None,
+        environ: dict | None = None,
     ) -> None:
-        self._connection: Optional[service_connection.ServiceConnection] = None
+        self._connection: ServiceConnection | None = 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._sweep_config: dict | None = None
+        self._config: dict | None = None
+        self._server: server.Server | None = None
         self._pid = pid
 
         # keep track of multiple runs, so we can unwind with join()s
-        self._global_run_stack: List[wandb_run.Run] = []
+        self._global_run_stack: list[Run] = []
 
         # TODO(jhr): defer strict checks until settings are fully initialized
         #            and logging is ready
@@ -107,79 +108,76 @@ class _WandbSetup__WandbSetup:  # noqa: N801
         _set_logger(self._early_logger)
 
         self._settings = self._settings_setup(settings, self._early_logger)
-        # self._settings.freeze()
 
         wandb.termsetup(self._settings, logger)
 
         self._check()
         self._setup()
 
-        tracelog_mode = self._settings._tracelog
-        if tracelog_mode:
-            tracelog.enable(tracelog_mode)
-
     def _settings_setup(
         self,
-        settings: Optional[Settings] = None,
-        early_logger: Optional[_EarlyLogger] = None,
-    ) -> "wandb_settings.Settings":
+        settings: Settings | None = None,
+        early_logger: _EarlyLogger | None = None,
+    ) -> wandb_settings.Settings:
         s = wandb_settings.Settings()
-        s._apply_base(pid=self._pid, _logger=early_logger)
-        s._apply_config_files(_logger=early_logger)
-        s._apply_env_vars(self._environ, _logger=early_logger)
 
-        if isinstance(settings, wandb_settings.Settings):
-            s._apply_settings(settings, _logger=early_logger)
-        elif isinstance(settings, dict):
-            # if passed settings arg is a mapping, update the settings with it
-            s._apply_setup(settings, _logger=early_logger)
+        # the pid of the process to monitor for system stats
+        pid = os.getpid()
+        if early_logger:
+            early_logger.info(f"Current SDK version is {wandb.__version__}")
+            early_logger.info(f"Configure stats pid to {pid}")
+        s.x_stats_pid = pid
+
+        # load settings from the system config
+        if s.settings_system and early_logger:
+            early_logger.info(f"Loading settings from {s.settings_system}")
+        s.update_from_system_config_file()
+
+        # load settings from the workspace config
+        if s.settings_workspace and early_logger:
+            early_logger.info(f"Loading settings from {s.settings_workspace}")
+        s.update_from_workspace_config_file()
+
+        # load settings from the environment variables
+        if early_logger:
+            early_logger.info("Loading settings from environment variables")
+        s.update_from_env_vars(self._environ)
+
+        # infer settings from the system environment
+        s.update_from_system_environment()
 
-        s._infer_settings_from_environment()
-        if not s._cli_only_mode:
-            s._infer_run_settings_from_environment(_logger=early_logger)
+        # load settings from the passed init/setup settings
+        if settings:
+            s.update_from_settings(settings)
 
         return s
 
-    def _update(
-        self,
-        settings: Optional[Settings] = None,
-    ) -> None:
-        if settings is None:
+    def _update(self, settings: Settings | None = None) -> None:
+        if not settings:
             return
-        # self._settings.unfreeze()
-        if isinstance(settings, wandb_settings.Settings):
-            # todo: check the logic here. this _only_ comes up in tests?
-            self._settings._apply_settings(settings)
-        elif isinstance(settings, dict):
-            # if it is a mapping, update the settings with it
-            self._settings.update(settings, source=wandb_settings.Source.SETUP)
-        # self._settings.freeze()
-
-    def _update_user_settings(self, settings: Optional[Settings] = None) -> None:
-        settings = settings or self._settings
+        self._settings.update_from_settings(settings)
+
+    def _update_user_settings(self) -> None:
         # Get rid of cached results to force a refresh.
         self._server = None
-        user_settings = self._load_user_settings(settings=settings)
+        user_settings = self._load_user_settings()
         if user_settings is not None:
-            # self._settings.unfreeze()
-            self._settings._apply_user(user_settings)
-            # self._settings.freeze()
+            self._settings.update_from_dict(user_settings)
 
     def _early_logger_flush(self, new_logger: Logger) -> None:
         if not self._early_logger:
             return
         _set_logger(new_logger)
-        # self._settings._clear_early_logger()
         self._early_logger._flush()
 
-    def _get_logger(self) -> Optional[Logger]:
+    def _get_logger(self) -> Logger | None:
         return logger
 
     @property
-    def settings(self) -> "wandb_settings.Settings":
+    def settings(self) -> wandb_settings.Settings:
         return self._settings
 
-    def _get_entity(self) -> Optional[str]:
+    def _get_entity(self) -> str | None:
         if self._settings and self._settings._offline:
             return None
         if self._server is None:
@@ -188,16 +186,15 @@ class _WandbSetup__WandbSetup:  # noqa: N801
         entity = self._server._viewer.get("entity")
         return entity
 
-    def _get_username(self) -> Optional[str]:
+    def _get_username(self) -> str | None:
         if self._settings and self._settings._offline:
             return None
         if self._server is None:
             self._load_viewer()
         assert self._server is not None
-        username = self._server._viewer.get("username")
-        return username
+        return self._server._viewer.get("username")
 
-    def _get_teams(self) -> List[str]:
+    def _get_teams(self) -> list[str]:
         if self._settings and self._settings._offline:
             return []
         if self._server is None:
@@ -208,20 +205,16 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             teams = [team["node"]["name"] for team in teams["edges"]]
         return teams or []
 
-    def _load_viewer(self, settings: Optional[Settings] = None) -> None:
+    def _load_viewer(self) -> None:
         if self._settings and self._settings._offline:
             return
-        if isinstance(settings, dict):
-            settings = wandb_settings.Settings(**settings)
-        s = server.Server(settings=settings)
+        s = server.Server(settings=self._settings)
         s.query_with_timeout()
         self._server = s
 
-    def _load_user_settings(
-        self, settings: Optional[Settings] = None
-    ) -> Optional[Dict[str, Any]]:
+    def _load_user_settings(self) -> dict[str, Any] | None:
         if self._server is None:
-            self._load_viewer(settings=settings)
+            self._load_viewer()
 
         # offline?
         if self._server is None:
@@ -248,7 +241,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             print("frozen, could be trouble")
 
     def _setup(self) -> None:
-        if not self._settings._noop and not self._settings._disable_service:
+        if not self._settings._noop and not self._settings.x_disable_service:
             from wandb.sdk.lib import service_connection
 
             self._connection = service_connection.connect_to_service(self._settings)
@@ -271,7 +264,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
                 else:
                     self._config = config_dict
 
-    def _teardown(self, exit_code: Optional[int] = None) -> None:
+    def _teardown(self, exit_code: int | None = None) -> None:
         import_hooks.unregister_all_post_import_hooks()
 
         if not self._connection:
@@ -286,7 +279,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             sys.exit(internal_exit_code)
 
     @property
-    def service(self) -> "Optional[service_connection.ServiceConnection]":
+    def service(self) -> ServiceConnection | None:
         """Returns a connection to the service process, if it exists."""
         return self._connection
 
@@ -298,9 +291,9 @@ class _WandbSetup:
     (Forked processes will get a new copy of the object)
     """
 
-    _instance: Optional["_WandbSetup__WandbSetup"] = None
+    _instance: _WandbSetup__WandbSetup | None = None
 
-    def __init__(self, settings: Optional[Settings] = None) -> None:
+    def __init__(self, settings: Settings | None = None) -> None:
         pid = os.getpid()
         if _WandbSetup._instance and _WandbSetup._instance._pid == pid:
             _WandbSetup._instance._update(settings=settings)
@@ -308,7 +301,7 @@ class _WandbSetup:
         _WandbSetup._instance = _WandbSetup__WandbSetup(settings=settings, pid=pid)
 
     @property
-    def service(self) -> "Optional[service_connection.ServiceConnection]":
+    def service(self) -> ServiceConnection | None:
         """Returns a connection to the service process, if it exists."""
         if not self._instance:
             return None
@@ -319,9 +312,9 @@ class _WandbSetup:
 
 
 def _setup(
-    settings: Optional[Settings] = None,
+    settings: Settings | None = None,
     _reset: bool = False,
-) -> Optional["_WandbSetup"]:
+) -> _WandbSetup | None:
     """Set up library context."""
     if _reset:
         teardown()
@@ -331,7 +324,7 @@ def _setup(
     return wl
 
 
-def setup(settings: Optional[Settings] = None) -> Optional["_WandbSetup"]:
+def setup(settings: Settings | None = None) -> _WandbSetup | None:
     """Prepares W&B for use in the current process and its children.
 
     You can usually ignore this as it is implicitly called by `wandb.init()`.
@@ -346,8 +339,8 @@ def setup(settings: Optional[Settings] = None) -> Optional["_WandbSetup"]:
     See also `wandb.teardown()`.
 
     Args:
-        settings (Optional[Union[Dict[str, Any], wandb.Settings]]): Configuration settings
-            to apply globally. These can be overridden by subsequent `wandb.init()` calls.
+        settings: Configuration settings to apply globally. These can be
+            overridden by subsequent `wandb.init()` calls.
 
     Example:
         ```python
@@ -391,7 +384,7 @@ def setup(settings: Optional[Settings] = None) -> Optional["_WandbSetup"]:
     return ret
 
 
-def teardown(exit_code: Optional[int] = None) -> None:
+def teardown(exit_code: int | None = None) -> None:
     """Waits for wandb to finish and frees resources.
 
     Completes any runs that were not explicitly finished

wandb/sdk/wandb_watch.py

@@ -100,7 +100,7 @@ def _watch(
         _global_watch_idx += 1
         if global_idx > 0:
             # TODO: this makes ugly chart names like gradients/graph_1conv1d.bias
-            prefix = "graph_%i" % global_idx
+            prefix = f"graph_{global_idx}"
 
         if log_parameters:
             run._torch.add_log_parameters_hook(

wandb/sync/sync.py

@@ -183,8 +183,7 @@ class SyncThread(threading.Thread):
         settings = wandb.Settings(
             root_dir=self._tmp_dir.name,
             run_id=proto_run.run_id,
-            _start_datetime=datetime.datetime.now(),
-            _start_time=time.time(),
+            x_start_time=time.time(),
         )
 
         settings_static = SettingsStatic(settings.to_proto())

wandb/util.py

@@ -82,6 +82,8 @@ T = TypeVar("T")
 logger = logging.getLogger(__name__)
 _not_importable = set()
 
+LAUNCH_JOB_ARTIFACT_SLOT_NAME = "_wandb_job"
+
 MAX_LINE_BYTES = (10 << 20) - (100 << 10)  # imposed by back end
 IS_GIT = os.path.exists(os.path.join(os.path.dirname(__file__), "..", ".git"))
 
@@ -102,35 +104,6 @@ else:
     SENTRY_ENV = "production"
 
 
-PLATFORM_WINDOWS = "windows"
-PLATFORM_LINUX = "linux"
-PLATFORM_BSD = "bsd"
-PLATFORM_DARWIN = "darwin"
-PLATFORM_UNKNOWN = "unknown"
-
-LAUNCH_JOB_ARTIFACT_SLOT_NAME = "_wandb_job"
-
-
-def get_platform_name() -> str:
-    if sys.platform.startswith("win"):
-        return PLATFORM_WINDOWS
-    elif sys.platform.startswith("darwin"):
-        return PLATFORM_DARWIN
-    elif sys.platform.startswith("linux"):
-        return PLATFORM_LINUX
-    elif sys.platform.startswith(
-        (
-            "dragonfly",
-            "freebsd",
-            "netbsd",
-            "openbsd",
-        )
-    ):
-        return PLATFORM_BSD
-    else:
-        return PLATFORM_UNKNOWN
-
-
 POW_10_BYTES = [
     ("B", 10**0),
     ("KB", 10**3),
@@ -1906,14 +1879,8 @@ class InstalledDistribution:
 
 
 def working_set() -> Iterable[InstalledDistribution]:
-    """Return the working set of installed distributions.
-
-    Uses importlib.metadata in Python versions above 3.7, and importlib_metadata otherwise.
-    """
-    try:
-        from importlib.metadata import distributions
-    except ImportError:
-        from importlib_metadata import distributions  # type: ignore
+    """Return the working set of installed distributions."""
+    from importlib.metadata import distributions
 
     for d in distributions():
         try:
@@ -1971,9 +1938,9 @@ def get_core_path() -> str:
     bin_path = pathlib.Path(__file__).parent / "bin" / "wandb-core"
     if not bin_path.exists():
         raise WandbCoreNotAvailableError(
-            f"Looks like wandb-core is not compiled for your system ({platform.platform()}):"
-            " Please contact support at support@wandb.com to request `wandb-core`"
-            " support for your system."
+            f"File not found: {bin_path}."
+            " Please contact support at support@wandb.com."
+            f" Your platform is: {platform.platform()}."
         )
 
     return str(bin_path)

wandb/wandb_controller.py

@@ -590,13 +590,11 @@ class _WandbController:
         stopper = self._custom_stopping or sweeps.stop_runs
         stop_runs = stopper(self._sweep_config, self._sweep_runs or [])
 
-        debug_lines = "\n".join(
-            [
-                " ".join([f"{k}={v}" for k, v in run.early_terminate_info.items()])
-                for run in stop_runs
-                if run.early_terminate_info is not None
-            ]
-        )
+        debug_lines = [
+            " ".join([f"{k}={v}" for k, v in run.early_terminate_info.items()])
+            for run in stop_runs
+            if run.early_terminate_info is not None
+        ]
         if debug_lines:
             self._log_debug += debug_lines
 
@@ -680,7 +678,7 @@ def _get_runs_status(metrics):
     for c in categories:
         if not metrics.get(c):
             continue
-        mlist.append("%s: %d" % (c.capitalize(), metrics[c]))
+        mlist.append(f"{c.capitalize()}: {metrics[c]}")
     s = ", ".join(mlist)
     return s
 
@@ -698,9 +696,9 @@ def _sweep_status(
     stopping = len([r for r in sweep_runs if r.should_stop])
     stopstr = ""
     if stopped or stopping:
-        stopstr = "Stopped: %d" % stopped
+        stopstr = f"Stopped: {stopped}"
         if stopping:
-            stopstr += " (Stopping: %d)" % stopping
+            stopstr += f" (Stopping: {stopping})"
     runs_status = _get_runs_status(run_type_counts)
     method = sweep_conf.get("method", "unknown")
     stopping = sweep_conf.get("early_terminate", None)
@@ -712,9 +710,9 @@ def _sweep_status(
     sections = []
     sections.append(f"Sweep: {sweep} ({sweep_options})")
     if runs_status:
-        sections.append("Runs: %d (%s)" % (run_count, runs_status))
+        sections.append(f"Runs: {run_count} ({runs_status})")
     else:
-        sections.append("Runs: %d" % (run_count))
+        sections.append(f"Runs: {run_count}")
     if stopstr:
         sections.append(stopstr)
     sections = " | ".join(sections)

{wandb-0.18.6.dist-info → wandb-0.19.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.18.6
+Version: 0.19.0rc1
 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
@@ -27,7 +27,6 @@ License: MIT License
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
-License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -36,19 +35,20 @@ Classifier: Natural Language :: English
 Classifier: Programming Language :: Go
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Logging
 Classifier: Topic :: System :: Monitoring
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Requires-Dist: click!=8.0.0,>=7.1
 Requires-Dist: docker-pycreds>=0.4.0
+Requires-Dist: eval-type-backport; python_version < '3.10'
 Requires-Dist: gitpython!=3.1.29,>=1.0.0
 Requires-Dist: platformdirs
 Requires-Dist: protobuf!=4.21.0,!=5.28.0,<6,>=3.12.0; python_version < '3.9' and sys_platform == 'linux'
@@ -56,6 +56,7 @@ Requires-Dist: protobuf!=4.21.0,!=5.28.0,<6,>=3.15.0; python_version == '3.9' an
 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: pydantic<3,>=2.6
 Requires-Dist: pyyaml
 Requires-Dist: requests<3,>=2.0.0
 Requires-Dist: sentry-sdk>=2.0.0
@@ -193,6 +194,14 @@ Use your favorite framework with W&B. W&B integrations make it fast and easy to
 
 &nbsp;
 
+# Python Version Support
+
+We are committed to supporting our minimum required Python version for *at least* six months after its official end-of-life (EOL) date, as defined by the Python Software Foundation. You can find a list of Python EOL dates [here](https://devguide.python.org/versions/).
+
+When we discontinue support for a Python version, we will increment the library’s minor version number to reflect this change.
+
+&nbsp;
+
 # Contribution guidelines
 Weights & Biases ❤️ open source, and we welcome contributions from the community! See the [Contribution guide](https://github.com/wandb/wandb/blob/main/CONTRIBUTING.md) for more information on the development workflow and the internals of the wandb library. For wandb bugs and feature requests, visit [GitHub Issues](https://github.com/wandb/wandb/issues) or contact support@wandb.com.