wandb 0.19.9__py3-none-musllinux_1_2_aarch64.whl → 0.19.11__py3-none-musllinux_1_2_aarch64.whl

wandb/sdk/wandb_settings.py

@@ -246,7 +246,7 @@ class Settings(BaseModel, validate_assignment=True):
 
       "wrap_emu" - Same as "wrap" but captures output through an emulator.
       Derived from the `wrap` setting and should not be set manually.
-      """
+    """
 
     console_multipart: bool = False
     """Whether to produce multipart console log files."""
@@ -376,6 +376,7 @@ class Settings(BaseModel, validate_assignment=True):
             "default",
             "return_previous",
             "finish_previous",
+            "create_new",
         ],
         bool,
     ] = "default"
@@ -384,8 +385,14 @@ class Settings(BaseModel, validate_assignment=True):
     Options:
     - "default": Use "finish_previous" in notebooks and "return_previous"
         otherwise.
-    - "return_previous": Return the active run.
-    - "finish_previous": Finish the active run, then return a new one.
+    - "return_previous": Return the most recently created run
+        that is not yet finished. This does not update `wandb.run`; see
+        the "create_new" option.
+    - "finish_previous": Finish all active runs, then return a new run.
+    - "create_new": Create a new run without modifying other active runs.
+        Does not update `wandb.run` and top-level functions like `wandb.log`.
+        Because of this, some older integrations that rely on the global run
+        will not work.
 
     Can also be a boolean, but this is deprecated. False is the same as
     "return_previous", and True is the same as "finish_previous".
@@ -458,11 +465,7 @@ class Settings(BaseModel, validate_assignment=True):
     save_code: Optional[bool] = None
     """Whether to save the code associated with the run."""
 
-    settings_system: str = Field(
-        default_factory=lambda: _path_convert(
-            os.path.join("~", ".config", "wandb", "settings")
-        )
-    )
+    settings_system: Optional[str] = None
     """Path to the system-wide settings file."""
 
     show_colors: Optional[bool] = None
@@ -689,6 +692,12 @@ class Settings(BaseModel, validate_assignment=True):
     This does not disable user-provided summary updates.
     """
 
+    x_server_side_expand_glob_metrics: bool = False
+    """Flag to delegate glob matching of metrics in define_metric to the server.
+
+    If the server does not support this, the client will perform the glob matching.
+    """
+
     x_service_transport: Optional[str] = None
     """Transport method for communication with the wandb service."""
 
@@ -1052,9 +1061,12 @@ class Settings(BaseModel, validate_assignment=True):
     @field_validator("settings_system", mode="after")
     @classmethod
     def validate_settings_system(cls, value):
-        if isinstance(value, pathlib.Path):
+        if value is None:
+            return None
+        elif isinstance(value, pathlib.Path):
             return str(_path_convert(value))
-        return _path_convert(value)
+        else:
+            return _path_convert(value)
 
     @field_validator("x_service_wait", mode="after")
     @classmethod
@@ -1662,6 +1674,11 @@ class Settings(BaseModel, validate_assignment=True):
         if not root:
             return None
 
+        # For windows if the root and program are on different drives,
+        # os.path.relpath will raise a ValueError.
+        if not util.are_paths_on_same_drive(root, program):
+            return None
+
         full_path_to_program = os.path.join(
             root, os.path.relpath(os.getcwd(), root), program
         )

wandb/sdk/wandb_setup.py

@@ -15,18 +15,21 @@ from __future__ import annotations
 
 import logging
 import os
+import pathlib
 import sys
 import threading
 from typing import TYPE_CHECKING, Any, Union
 
 import wandb
 import wandb.integration.sagemaker as sagemaker
+from wandb.env import CONFIG_DIR
 from wandb.sdk.lib import import_hooks, wb_logging
 
 from . import wandb_settings
 from .lib import config_util, server
 
 if TYPE_CHECKING:
+    from wandb.sdk import wandb_run
     from wandb.sdk.lib.service_connection import ServiceConnection
     from wandb.sdk.wandb_settings import Settings
 
@@ -83,6 +86,8 @@ class _WandbSetup:
     ) -> None:
         self._connection: ServiceConnection | None = None
 
+        self._active_runs: list[wandb_run.Run] = []
+
         self._environ = environ or dict(os.environ)
         self._sweep_config: dict | None = None
         self._config: dict | None = None
@@ -100,6 +105,52 @@ class _WandbSetup:
         self._check()
         self._setup()
 
+    def add_active_run(self, run: wandb_run.Run) -> None:
+        """Append a run to the active runs list.
+
+        This must be called when a run is initialized.
+
+        Args:
+            run: A newly initialized run.
+        """
+        if run not in self._active_runs:
+            self._active_runs.append(run)
+
+    def remove_active_run(self, run: wandb_run.Run) -> None:
+        """Remove the run from the active runs list.
+
+        This must be called when a run is finished.
+
+        Args:
+            run: A run that is finished or crashed.
+        """
+        try:
+            self._active_runs.remove(run)
+        except ValueError:
+            pass  # Removing a run multiple times is not an error.
+
+    @property
+    def most_recent_active_run(self) -> wandb_run.Run | None:
+        """The most recently initialized run that is not yet finished."""
+        if not self._active_runs:
+            return None
+
+        return self._active_runs[-1]
+
+    def finish_all_active_runs(self) -> None:
+        """Finish all unfinished runs.
+
+        NOTE: This is slightly inefficient as it finishes runs one at a time.
+        This only exists to support using the `reinit="finish_previous"`
+        setting together with `reinit="create_new"` which does not seem to be a
+        useful pattern. Since `"create_new"` should eventually become the
+        default and only behavior, it does not seem worth optimizing.
+        """
+        # Take a snapshot as each call to `finish()` modifies `_active_runs`.
+        runs_copy = list(self._active_runs)
+        for run in runs_copy:
+            run.finish()
+
     def _settings_setup(
         self,
         settings: Settings | None,
@@ -112,6 +163,16 @@ class _WandbSetup:
         self._logger.info(f"Configure stats pid to {pid}")
         s.x_stats_pid = pid
 
+        if settings and settings.settings_system:
+            s.settings_system = settings.settings_system
+        elif config_dir_str := os.getenv(CONFIG_DIR, None):
+            config_dir = pathlib.Path(config_dir_str).expanduser()
+            s.settings_system = str(config_dir / "settings")
+        else:
+            s.settings_system = str(
+                pathlib.Path("~", ".config", "wandb", "settings").expanduser()
+            )
+
         # load settings from the system config
         if s.settings_system:
             self._logger.info(f"Loading settings from {s.settings_system}")

wandb/util.py

@@ -51,6 +51,11 @@ from typing import (
     Union,
 )
 
+if sys.version_info < (3, 10):
+    from typing_extensions import TypeGuard
+else:
+    from typing import TypeGuard
+
 import requests
 import yaml
 
@@ -184,6 +189,13 @@ class LazyModuleState:
             self.module.__spec__.loader.exec_module(self.module)
             self.module.__class__ = types.ModuleType
 
+            # Set the submodule as an attribute on the parent module
+            # This enables access to the submodule via normal attribute access.
+            parent, _, child = self.module.__name__.rpartition(".")
+            if parent:
+                parent_module = sys.modules[parent]
+                setattr(parent_module, child, self.module)
+
 
 class LazyModule(types.ModuleType):
     def __getattribute__(self, name: str) -> Any:
@@ -1060,18 +1072,6 @@ def has_num(dictionary: Mapping, key: Any) -> bool:
     return key in dictionary and isinstance(dictionary[key], numbers.Number)
 
 
-def get_log_file_path() -> str:
-    """Log file path used in error messages.
-
-    It would probably be better if this pointed to a log file in a
-    run directory.
-    """
-    # TODO(jhr, cvp): refactor
-    if wandb.run is not None:
-        return wandb.run._settings.log_internal
-    return os.path.join("wandb", "debug-internal.log")
-
-
 def docker_image_regex(image: str) -> Any:
     """Regex match for valid docker image names."""
     if image:
@@ -1438,6 +1438,24 @@ def auto_project_name(program: Optional[str]) -> str:
     return str(project.replace(os.sep, "_"))
 
 
+def are_paths_on_same_drive(path1: str, path2: str) -> bool:
+    """Check if two paths are on the same drive.
+
+    This check is only relevant on Windows,
+    since the concept of drives only exists on Windows.
+    """
+    if platform.system() != "Windows":
+        return True
+
+    try:
+        path1_drive = pathlib.Path(path1).resolve().drive
+        path2_drive = pathlib.Path(path2).resolve().drive
+        return path1_drive == path2_drive
+    # If either path is not a valid windows path, an OSError is raised.
+    except OSError:
+        return False
+
+
 # TODO(hugh): Deprecate version here and use wandb/sdk/lib/paths.py
 def to_forward_slash_path(path: str) -> str:
     if platform.system() == "Windows":
@@ -1698,15 +1716,15 @@ def _resolve_aliases(aliases: Optional[Union[str, Iterable[str]]]) -> List[str]:
         raise ValueError("`aliases` must be Iterable or None") from exc
 
 
-def _is_artifact_object(v: Any) -> bool:
+def _is_artifact_object(v: Any) -> "TypeGuard[wandb.Artifact]":
     return isinstance(v, wandb.Artifact)
 
 
-def _is_artifact_string(v: Any) -> bool:
+def _is_artifact_string(v: Any) -> "TypeGuard[str]":
     return isinstance(v, str) and v.startswith("wandb-artifact://")
 
 
-def _is_artifact_version_weave_dict(v: Any) -> bool:
+def _is_artifact_version_weave_dict(v: Any) -> "TypeGuard[dict]":
     return isinstance(v, dict) and v.get("_type") == "artifactVersion"
 
 
@@ -1750,20 +1768,6 @@ def _get_max_cli_version() -> Union[str, None]:
     return str(max_cli_version) if max_cli_version is not None else None
 
 
-def _is_offline() -> bool:
-    """Returns true if wandb is configured to be offline.
-
-    If there is an active run, returns whether the run is offline.
-    Otherwise, returns the default mode, which is affected by explicit settings
-    passed to `wandb.setup()`, environment variables, and W&B configuration
-    files.
-    """
-    if wandb.run:
-        return wandb.run.settings._offline
-    else:
-        return wandb.setup().settings._offline
-
-
 def ensure_text(
     string: Union[str, bytes], encoding: str = "utf-8", errors: str = "strict"
 ) -> str:

{wandb-0.19.9.dist-info → wandb-0.19.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wandb
-Version: 0.19.9
+Version: 0.19.11
 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
@@ -52,10 +52,10 @@ 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'
-Requires-Dist: protobuf!=4.21.0,!=5.28.0,<6,>=3.15.0; python_version == '3.9' and sys_platform == 'linux'
-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: protobuf!=4.21.0,!=5.28.0,<7,>=3.12.0; python_version < '3.9' and sys_platform == 'linux'
+Requires-Dist: protobuf!=4.21.0,!=5.28.0,<7,>=3.15.0; python_version == '3.9' and sys_platform == 'linux'
+Requires-Dist: protobuf!=4.21.0,!=5.28.0,<7,>=3.19.0; python_version > '3.9' and sys_platform == 'linux'
+Requires-Dist: protobuf!=4.21.0,!=5.28.0,<7,>=3.19.0; sys_platform != 'linux'
 Requires-Dist: psutil>=5.0.0
 Requires-Dist: pydantic<3
 Requires-Dist: pyyaml