wandb 0.19.8__py3-none-win_amd64.whl → 0.19.9__py3-none-win_amd64.whl

wandb/sdk/internal/settings_static.py

@@ -21,11 +21,33 @@ class SettingsStatic(Settings):
     def _proto_to_dict(self, proto: wandb_settings_pb2.Settings) -> dict:
         data = {}
 
+        exclude_fields = {
+            "model_config",
+            "model_fields",
+            "model_fields_set",
+            "__fields__",
+            "__model_fields_set",
+            "__pydantic_self__",
+            "__pydantic_initialised__",
+        }
+
+        fields = (
+            Settings.model_fields
+            if hasattr(Settings, "model_fields")
+            else Settings.__fields__
+        )  # type: ignore [attr-defined]
+
+        fields = {k: v for k, v in fields.items() if k not in exclude_fields}  # type: ignore [union-attr]
+
         forks_specified: list[str] = []
-        for key in Settings.model_fields:  # type: ignore [attr-defined]
+        for key in fields:
+            # Skip Python-only keys that do not exist on the proto.
+            if key in ("reinit",):
+                continue
+
             value: Any = None
 
-            field_info = Settings.model_fields[key]
+            field_info = fields[key]
             annotation = str(field_info.annotation)
 
             if key == "_stats_open_metrics_filters":

wandb/sdk/lib/apikey.py

@@ -11,7 +11,7 @@ import textwrap
 from functools import partial
 
 # import Literal
-from typing import TYPE_CHECKING, Callable, Dict, Literal, Optional, Union
+from typing import TYPE_CHECKING, Callable, Literal
 from urllib.parse import urlparse
 
 import click
@@ -23,6 +23,9 @@ from wandb.errors import term
 from wandb.errors.links import url_registry
 from wandb.util import _is_databricks, isatty, prompt_choices
 
+if TYPE_CHECKING:
+    from wandb.sdk.wandb_settings import Settings
+
 LOGIN_CHOICE_ANON = "Private W&B dashboard, no account required"
 LOGIN_CHOICE_NEW = "Create a W&B account"
 LOGIN_CHOICE_EXISTS = "Use an existing W&B account"
@@ -50,18 +53,14 @@ class WriteNetrcError(Exception):
 Mode = Literal["allow", "must", "never", "false", "true"]
 
 
-if TYPE_CHECKING:
-    from wandb.sdk.wandb_settings import Settings
-
-
 getpass = partial(click.prompt, hide_input=True, err=True)
 
 
-def _fixup_anon_mode(default: Optional[Mode]) -> Optional[Mode]:
+def _fixup_anon_mode(default: Mode | None) -> Mode | None:
     # Convert weird anonymode values from legacy settings files
     # into one of our expected values.
     anon_mode = default or "never"
-    mapping: Dict[Mode, Mode] = {"true": "allow", "false": "never"}
+    mapping: dict[Mode, Mode] = {"true": "allow", "false": "never"}
     return mapping.get(anon_mode, anon_mode)
 
 
@@ -85,14 +84,14 @@ def get_netrc_file_path() -> str:
 
 
 def prompt_api_key(  # noqa: C901
-    settings: "Settings",
-    api: Optional[InternalApi] = None,
-    input_callback: Optional[Callable] = None,
-    browser_callback: Optional[Callable] = None,
+    settings: Settings,
+    api: InternalApi | None = None,
+    input_callback: Callable | None = None,
+    browser_callback: Callable | None = None,
     no_offline: bool = False,
     no_create: bool = False,
     local: bool = False,
-) -> Union[str, bool, None]:
+) -> str | bool | None:
     """Prompt for api key.
 
     Returns:
@@ -276,9 +275,9 @@ def write_netrc(host: str, entity: str, key: str):
 
 
 def write_key(
-    settings: "Settings",
-    key: Optional[str],
-    api: Optional["InternalApi"] = None,
+    settings: Settings,
+    key: str | None,
+    api: InternalApi | None = None,
 ) -> None:
     if not key:
         raise ValueError("No API key specified.")
@@ -298,7 +297,7 @@ def write_key(
     write_netrc(settings.base_url, "user", key)
 
 
-def api_key(settings: Optional["Settings"] = None) -> Optional[str]:
+def api_key(settings: Settings | None = None) -> str | None:
     if settings is None:
         settings = wandb.setup().settings
     if settings.api_key:

wandb/sdk/lib/run_moment.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Literal, cast
+from typing import Union
 from urllib import parse
 
-_STEP = Literal["_step"]
-
 
 @dataclass
 class RunMoment:
@@ -19,10 +17,10 @@ class RunMoment:
     run: str
     """run ID"""
 
-    value: int | float
+    value: Union[int, float]
     """Value of the metric."""
 
-    metric: _STEP = "_step"
+    metric: str = "_step"
     """Metric to use to determine the moment in the run.
 
     Currently, only the metric '_step' is supported.
@@ -81,4 +79,4 @@ class RunMoment:
         except ValueError as e:
             raise parse_err from e
 
-        return cls(run=run, metric=cast(_STEP, metric), value=num_value)
+        return cls(run=run, metric=metric, value=num_value)

wandb/sdk/lib/wb_logging.py

@@ -0,0 +1,161 @@
+"""Logging configuration for the "wandb" logger.
+
+Most log statements in wandb are made in the context of a run and should be
+redirected to that run's log file (usually named 'debug.log'). This module
+provides a context manager to temporarily set the current run ID and registers
+a global handler for the 'wandb' logger that sends log statements to the right
+place.
+
+All functions in this module are threadsafe.
+
+NOTE: The pytest caplog fixture will fail to capture logs from the wandb logger
+because they are not propagated to the root logger.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import contextvars
+import logging
+import pathlib
+from typing import Iterator
+
+
+class _NotRunSpecific:
+    """Sentinel for `not_run_specific()`."""
+
+
+_NOT_RUN_SPECIFIC = _NotRunSpecific()
+
+
+_run_id: contextvars.ContextVar[str | _NotRunSpecific | None] = contextvars.ContextVar(
+    "_run_id",
+    default=None,
+)
+
+_logger = logging.getLogger("wandb")
+
+
+def configure_wandb_logger() -> None:
+    """Configures the global 'wandb' logger.
+
+    The wandb logger is not intended to be customized by users. Instead, it is
+    used as a mechanism to redirect log messages into wandb run-specific log
+    files.
+
+    This function is idempotent: calling it multiple times has the same effect.
+    """
+    # Send all DEBUG and above messages to registered handlers.
+    #
+    # Per-run handlers can set different levels.
+    _logger.setLevel(logging.DEBUG)
+
+    # Do not propagate wandb logs to the root logger, which the user may have
+    # configured to point elsewhere. All wandb log messages should go to a run's
+    # log file.
+    _logger.propagate = False
+
+    # If no handlers are configured for the 'wandb' logger, don't activate the
+    # "lastResort" handler which sends messages to stderr with a level of
+    # WARNING by default.
+    #
+    # This occurs in wandb code that runs outside the context of a Run and
+    # not as part of the CLI.
+    #
+    # Most such code uses the `termlog` / `termwarn` / `termerror` methods
+    # to communicate with the user. When that code executes while a run is
+    # active, its logger messages go to that run's log file.
+    if not _logger.handlers:
+        _logger.addHandler(logging.NullHandler())
+
+
+@contextlib.contextmanager
+def log_to_run(run_id: str | None) -> Iterator[None]:
+    """Direct all wandb log messages to the given run.
+
+    Args:
+        id: The current run ID, or None if actions in the context manager are
+            not associated to a specific run. In the latter case, log messages
+            will go to all runs.
+
+    Usage:
+
+        with wb_logging.run_id(...):
+            ... # Log messages here go to the specified run's logger.
+    """
+    token = _run_id.set(run_id)
+    try:
+        yield
+    finally:
+        _run_id.reset(token)
+
+
+@contextlib.contextmanager
+def log_to_all_runs() -> Iterator[None]:
+    """Direct wandb log messages to all runs.
+
+    Unlike `log_to_run(None)`, this indicates an intentional choice.
+    This is often convenient to use as a decorator:
+
+        @wb_logging.log_to_all_runs()
+        def my_func():
+            ... # Log messages here go to the specified run's logger.
+    """
+    token = _run_id.set(_NOT_RUN_SPECIFIC)
+    try:
+        yield
+    finally:
+        _run_id.reset(token)
+
+
+def add_file_handler(run_id: str, filepath: pathlib.Path) -> logging.Handler:
+    """Direct log messages for a run to a file.
+
+    Args:
+        run_id: The run for which to create a log file.
+        filepath: The file to write log messages to.
+
+    Returns:
+        The added handler which can then be configured further or removed
+        from the 'wandb' logger directly.
+
+        The default logging level is INFO.
+    """
+    handler = logging.FileHandler(filepath)
+    handler.setLevel(logging.INFO)
+    handler.addFilter(_RunIDFilter(run_id))
+    handler.setFormatter(
+        logging.Formatter(
+            "%(asctime)s %(levelname)-7s %(threadName)-10s:%(process)d"
+            " [%(filename)s:%(funcName)s():%(lineno)s]%(run_id_tag)s"
+            " %(message)s"
+        )
+    )
+
+    _logger.addHandler(handler)
+    return handler
+
+
+class _RunIDFilter(logging.Filter):
+    """Filters out messages logged for a different run."""
+
+    def __init__(self, run_id: str) -> None:
+        """Create a _RunIDFilter.
+
+        Args:
+            run_id: Allows messages when the run ID is this or None.
+        """
+        self._run_id = run_id
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        run_id = _run_id.get()
+
+        if run_id is None:
+            record.run_id_tag = " [no run ID]"
+            return True
+        elif isinstance(run_id, _NotRunSpecific):
+            record.run_id_tag = " [all runs]"
+            return True
+        else:
+            record.run_id_tag = ""
+            return run_id == self._run_id

wandb/sdk/wandb_config.py

@@ -22,65 +22,63 @@ logger = logging.getLogger("wandb")
 class Config:
     """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.
+    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.
 
-    We recommend setting `wandb.config` once at the top of your training experiment or
-    setting the config as a parameter to init, ie. `wandb.init(config=my_config_dict)`
+    We recommend setting the config once when initializing your run by passing
+    the `config` parameter to `init`:
 
-    You can create a file called `config-defaults.yaml`, and it will automatically be
-    loaded into `wandb.config`. See https://docs.wandb.com/guides/track/config#file-based-configs.
+    ```
+    wandb.init(config=my_config_dict)
+    ```
+
+    You can create a file called `config-defaults.yaml`, and it will
+    automatically be loaded as each run's config. You can also pass the name
+    of the file as the `config` parameter to `init`:
+
+    ```
+    wandb.init(config="my_config.yaml")
+    ```
 
-    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/guides/track/config#file-based-configs.
 
     Examples:
         Basic usage
         ```
-        wandb.config.epochs = 4
-        wandb.init()
-        for x in range(wandb.config.epochs):
-            # train
-        ```
-
-        Using wandb.init to set config
-        ```
-        wandb.init(config={"epochs": 4, "batch_size": 32})
-        for x in range(wandb.config.epochs):
-            # train
+        with wandb.init(config={"epochs": 4}) as run:
+            for x in range(run.config.epochs):
+                # train
         ```
 
-        Nested configs
+        Nested values
         ```
-        wandb.config['train']['epochs'] = 4
-        wandb.init()
-        for x in range(wandb.config['train']['epochs']):
-            # train
+        with wandb.init(config={"train": {"epochs": 4}}) as run:
+            for x in range(run.config["train"]["epochs"]):
+                # train
         ```
 
         Using absl flags
         ```
         flags.DEFINE_string("model", None, "model to run")  # name, default, help
-        wandb.config.update(flags.FLAGS)  # adds all absl flags to config
+        with wandb.init() as run:
+            run.config.update(flags.FLAGS)  # adds all absl flags to config
         ```
 
         Argparse flags
         ```python
-        wandb.init()
-        wandb.config.epochs = 4
-
-        parser = argparse.ArgumentParser()
-        parser.add_argument(
-            "-b",
-            "--batch-size",
-            type=int,
-            default=8,
-            metavar="N",
-            help="input batch size for training (default: 8)",
-        )
-        args = parser.parse_args()
-        wandb.config.update(args)
+        with wandb.init(config={"epochs": 4}) as run:
+            parser = argparse.ArgumentParser()
+            parser.add_argument(
+                "-b",
+                "--batch-size",
+                type=int,
+                default=8,
+                metavar="N",
+                help="input batch size for training (default: 8)",
+            )
+            args = parser.parse_args()
+            run.config.update(args)
         ```
 
         Using TensorFlow flags (deprecated in tensorflow v2)
@@ -88,7 +86,9 @@ class Config:
         flags = tf.app.flags
         flags.DEFINE_string("data_dir", "/tmp/data")
         flags.DEFINE_integer("batch_size", 128, "Batch size.")
-        wandb.config.update(flags.FLAGS)  # adds all of the tensorflow flags to config
+
+        with wandb.init() as run:
+            run.config.update(flags.FLAGS)
         ```
     """
 
@@ -298,7 +298,8 @@ class Config:
         # best if we don't allow nested artifacts until we can lock nested keys in the config
         if isinstance(v, dict) and check_dict_contains_nested_artifact(v, nested):
             raise ValueError(
-                "Instances of wandb.Artifact can only be top level keys in wandb.config"
+                "Instances of wandb.Artifact can only be top level keys in"
+                " a run's config"
             )
 
 
@@ -307,10 +308,10 @@ class ConfigStatic:
         object.__setattr__(self, "__dict__", dict(config))
 
     def __setattr__(self, name, value):
-        raise AttributeError("Error: wandb.run.config_static is a readonly object")
+        raise AttributeError("Error: run.config_static is a readonly object")
 
     def __setitem__(self, key, val):
-        raise AttributeError("Error: wandb.run.config_static is a readonly object")
+        raise AttributeError("Error: run.config_static is a readonly object")
 
     def keys(self):
         return self.__dict__.keys()