wandb 0.19.7__py3-none-win32.whl → 0.19.9__py3-none-win32.whl

wandb/sdk/mailbox/wait_with_progress.py

@@ -1,21 +1,22 @@
 from __future__ import annotations
 
 import time
-from typing import Any, Callable, Coroutine, List, cast
+from typing import Any, Callable, Coroutine, List, TypeVar, cast
 
-from wandb.proto import wandb_internal_pb2 as pb
 from wandb.sdk.lib import asyncio_compat
 
-from . import handles
+from .mailbox_handle import MailboxHandle
+
+_T = TypeVar("_T")
 
 
 def wait_with_progress(
-    handle: handles.MailboxHandle,
+    handle: MailboxHandle[_T],
     *,
     timeout: float | None,
     progress_after: float,
     display_progress: Callable[[], Coroutine[Any, Any, None]],
-) -> pb.Result:
+) -> _T:
     """Wait for a handle, possibly displaying progress to the user.
 
     Equivalent to passing a single handle to `wait_all_with_progress`.
@@ -29,12 +30,12 @@ def wait_with_progress(
 
 
 def wait_all_with_progress(
-    handle_list: list[handles.MailboxHandle],
+    handle_list: list[MailboxHandle[_T]],
     *,
     timeout: float | None,
     progress_after: float,
     display_progress: Callable[[], Coroutine[Any, Any, None]],
-) -> list[pb.Result]:
+) -> list[_T]:
     """Wait for multiple handles, possibly displaying progress to the user.
 
     Args:
@@ -70,7 +71,7 @@ def wait_all_with_progress(
     except TimeoutError:
         pass
 
-    async def progress_loop_with_timeout() -> list[pb.Result]:
+    async def progress_loop_with_timeout() -> list[_T]:
         with asyncio_compat.cancel_on_exit(display_progress()):
             if timeout is not None:
                 elapsed_time = time.monotonic() - start_time
@@ -87,10 +88,10 @@ def wait_all_with_progress(
 
 
 def _wait_handles(
-    handle_list: list[handles.MailboxHandle],
+    handle_list: list[MailboxHandle[_T]],
     *,
     timeout: float,
-) -> list[pb.Result]:
+) -> list[_T]:
     """Wait for multiple mailbox handles.
 
     Returns:
@@ -100,7 +101,7 @@ def _wait_handles(
         TimeoutError: If the overall timeout expires.
         HandleAbandonedError: If any handle becomes abandoned.
     """
-    results: list[pb.Result] = []
+    results: list[_T] = []
 
     start_time = time.monotonic()
     for handle in handle_list:
@@ -112,15 +113,15 @@ def _wait_handles(
 
 
 async def _wait_handles_async(
-    handle_list: list[handles.MailboxHandle],
+    handle_list: list[MailboxHandle[_T]],
     *,
     timeout: float | None,
-) -> list[pb.Result]:
+) -> list[_T]:
     """Asynchronously wait for multiple mailbox handles.
 
     Just like _wait_handles.
     """
-    results: list[pb.Result | None] = [None for _ in handle_list]
+    results: list[_T | None] = [None for _ in handle_list]
 
     async def wait_single(index: int) -> None:
         handle = handle_list[index]
@@ -131,4 +132,4 @@ async def _wait_handles_async(
             task_group.start_soon(wait_single(index))
 
     # NOTE: `list` is not subscriptable until Python 3.10, so we use List.
-    return cast(List[pb.Result], results)
+    return cast(List[_T], results)

wandb/sdk/service/server_sock.py

@@ -44,7 +44,10 @@ class SockServerInterfaceReaderThread(threading.Thread):
     _stopped: "Event"
 
     def __init__(
-        self, clients: ClientDict, iface: "InterfaceRelay", stopped: "Event"
+        self,
+        clients: ClientDict,
+        iface: "InterfaceRelay",
+        stopped: "Event",
     ) -> None:
         self._iface = iface
         self._clients = clients
@@ -53,7 +56,6 @@ class SockServerInterfaceReaderThread(threading.Thread):
         self._stopped = stopped
 
     def run(self) -> None:
-        assert self._iface.relay_q
         while not self._stopped.is_set():
             try:
                 result = self._iface.relay_q.get(timeout=1)

wandb/sdk/service/streams.py

@@ -21,16 +21,14 @@ import psutil
 import wandb
 import wandb.util
 from wandb.proto import wandb_internal_pb2 as pb
+from wandb.sdk.interface.interface_relay import InterfaceRelay
+from wandb.sdk.interface.router_relay import MessageRelayRouter
 from wandb.sdk.internal.settings_static import SettingsStatic
 from wandb.sdk.lib import asyncio_compat, progress
 from wandb.sdk.lib import printer as printerlib
 from wandb.sdk.mailbox import Mailbox, MailboxHandle, wait_all_with_progress
 from wandb.sdk.wandb_run import Run
 
-from ..interface.interface_relay import InterfaceRelay
-
-# from wandb.sdk.wandb_settings import Settings
-
 
 class StreamThread(threading.Thread):
     """Class to running internal process as a thread."""
@@ -62,6 +60,12 @@ class StreamRecord:
         self._record_q = queue.Queue()
         self._result_q = queue.Queue()
         self._relay_q = queue.Queue()
+        self._router = MessageRelayRouter(
+            request_queue=self._record_q,
+            response_queue=self._result_q,
+            relay_queue=self._relay_q,
+            mailbox=self._mailbox,
+        )
         self._iface = InterfaceRelay(
             record_q=self._record_q,
             result_q=self._result_q,
@@ -80,6 +84,7 @@ class StreamRecord:
 
     def join(self) -> None:
         self._iface.join()
+        self._router.join()
         if self._thread:
             self._thread.join()
 
@@ -290,7 +295,7 @@ class StreamMux:
 
         # fixme: for now we have a single printer for all streams,
         # and jupyter is disabled if at least single stream's setting set `_jupyter` to false
-        exit_handles: list[MailboxHandle] = []
+        exit_handles: list[MailboxHandle[pb.Result]] = []
 
         # only finish started streams, non started streams failed early
         started_streams: dict[str, StreamRecord] = {}

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()