wandb 0.18.6__py3-none-win32.whl → 0.19.0rc1__py3-none-win32.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.1
+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
@@ -36,19 +36,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 +57,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 +195,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.