wandb 0.19.3__py3-none-win32.whl → 0.19.4rc1__py3-none-win32.whl

wandb/__init__.py

@@ -10,7 +10,7 @@ For reference documentation, see https://docs.wandb.com/ref/python.
 """
 from __future__ import annotations
 
-__version__ = "0.19.3"
+__version__ = "0.19.4rc1"
 
 
 from wandb.errors import Error

wandb/__init__.pyi

@@ -103,7 +103,7 @@ if TYPE_CHECKING:
     import wandb
     from wandb.plot import CustomChart
 
-__version__: str = "0.19.3"
+__version__: str = "0.19.4rc1"
 
 run: Run | None
 config: wandb_config.Config

wandb/sdk/interface/interface.py

@@ -10,7 +10,6 @@ InterfaceRelay: Responses are routed to a relay queue (not matching uuids)
 
 import gzip
 import logging
-import os
 import time
 from abc import abstractmethod
 from pathlib import Path
@@ -100,8 +99,6 @@ class InterfaceBase:
 
     def _hack_set_run(self, run: "Run") -> None:
         self._run = run
-        current_pid = os.getpid()
-        self._run._set_iface_pid(current_pid)
 
     def publish_header(self) -> None:
         header = pb.HeaderRecord()
@@ -653,15 +650,13 @@ class InterfaceBase:
 
     def publish_partial_history(
         self,
+        run: "Run",
         data: dict,
         user_step: int,
         step: Optional[int] = None,
         flush: Optional[bool] = None,
         publish_step: bool = True,
-        run: Optional["Run"] = None,
     ) -> None:
-        run = run or self._run
-
         data = history_dict_to_json(run, data, step=user_step, ignore_copy_err=True)
         data.pop("_step", None)
 
@@ -688,12 +683,11 @@ class InterfaceBase:
 
     def publish_history(
         self,
+        run: "Run",
         data: dict,
         step: Optional[int] = None,
-        run: Optional["Run"] = None,
         publish_step: bool = True,
     ) -> None:
-        run = run or self._run
         data = history_dict_to_json(run, data, step=step)
         history = pb.HistoryRecord()
         if publish_step:

wandb/sdk/internal/tb_watcher.py

@@ -454,7 +454,9 @@ class TBEventConsumer:
                 row[chart.spec.table_key] = chart.table
 
         self._tbwatcher._interface.publish_history(
-            row, run=self._internal_run, publish_step=False
+            self._internal_run,
+            row,
+            publish_step=False,
         )
 
 

wandb/sdk/wandb_init.py

@@ -11,6 +11,7 @@ For more on using `wandb.init()`, including code snippets, check out our
 from __future__ import annotations
 
 import copy
+import dataclasses
 import json
 import logging
 import os
@@ -105,16 +106,40 @@ def _handle_launch_config(settings: Settings) -> dict[str, Any]:
     return launch_run_config
 
 
-class _WandbInit:
-    _init_telemetry_obj: telemetry.TelemetryRecord
+@dataclasses.dataclass(frozen=True)
+class _ConfigParts:
+    base_no_artifacts: dict[str, Any]
+    """The run config passed to `init()` minus any artifact-valued keys."""
+
+    sweep_no_artifacts: dict[str, Any]
+    """The config loaded as part of a sweep minus any artifact-valued keys."""
+
+    launch_no_artifacts: dict[str, Any]
+    """The config loaded as part of Launch minus any artifact-valued keys."""
+
+    artifacts: dict[str, Any]
+    """Artifact keys removed from config dictionaries.
+
+    Due to implementation details of how a Run is constructed,
+    artifacts must be inserted into its config after initialization.
+    """
+
 
-    def __init__(self, wl: wandb_setup._WandbSetup) -> None:
+class _WandbInit:
+    def __init__(
+        self,
+        wl: wandb_setup._WandbSetup,
+        telemetry: telemetry.TelemetryRecord,
+    ) -> None:
         self._wl = wl
 
+        self._telemetry = telemetry
+        """Telemetry gathered before creating a run.
+
+        After the run is created, `telemetry.context()` is used instead.
+        """
+
         self.kwargs = None
-        self.sweep_config: dict[str, Any] = {}
-        self.launch_config: dict[str, Any] = {}
-        self.config: dict[str, Any] = {}
         self.run: Run | None = None
         self.backend: Backend | None = None
 
@@ -122,8 +147,6 @@ class _WandbInit:
         self.notebook: wandb.jupyter.Notebook | None = None  # type: ignore
         self.printer = printer.new_printer()
 
-        self._init_telemetry_obj = telemetry.TelemetryRecord()
-
         self.deprecated_features_used: dict[str, str] = dict()
 
     @property
@@ -229,7 +252,7 @@ class _WandbInit:
             warn("run_id", init_settings.run_id)
             init_settings.run_id = None
 
-    def compute_run_settings(self, init_settings: Settings) -> Settings:
+    def make_run_settings(self, init_settings: Settings) -> Settings:
         """Returns the run's settings.
 
         Args:
@@ -250,8 +273,7 @@ class _WandbInit:
         if not settings.sagemaker_disable and sagemaker.is_using_sagemaker():
             if sagemaker.set_run_id(settings):
                 self._logger.info("set run ID and group based on SageMaker")
-                with telemetry.context(obj=self._init_telemetry_obj) as tel:
-                    tel.feature.sagemaker = True
+                self._telemetry.feature.sagemaker = True
 
         # get status of code saving before applying user settings
         save_code_pre_user_settings = settings.save_code
@@ -355,25 +377,24 @@ class _WandbInit:
                 run_id=settings.run_id,
             )
 
-    def setup(
+    def make_run_config(
         self,
         settings: Settings,
         config: dict | str | None = None,
         config_exclude_keys: list[str] | None = None,
         config_include_keys: list[str] | None = None,
-        monitor_gym: bool | None = None,
-    ) -> None:
-        """Compute the run's config and some telemetry."""
-        with telemetry.context(obj=self._init_telemetry_obj) as tel:
-            if config is not None:
-                tel.feature.set_init_config = True
-            if settings.run_name is not None:
-                tel.feature.set_init_name = True
-            if settings.run_id is not None:
-                tel.feature.set_init_id = True
-            if settings.run_tags is not None:
-                tel.feature.set_init_tags = True
+    ) -> _ConfigParts:
+        """Construct the run's config.
+
+        Args:
+            settings: The run's finalized settings.
+            config: The config passed to `init()`.
+            config_exclude_keys: Deprecated. Keys to filter out from `config`.
+            config_include_keys: Deprecated. Keys to include from `config`.
 
+        Returns:
+            Initial values for the run's config.
+        """
         # TODO: remove this once officially deprecated
         if config_exclude_keys:
             self.deprecated_features_used["config_exclude_keys"] = (
@@ -389,49 +410,51 @@ class _WandbInit:
             exclude=config_exclude_keys,
         )
 
-        # Construct the run's config.
-        self.config = dict()
-        self.init_artifact_config: dict[str, Any] = dict()
+        result = _ConfigParts(
+            base_no_artifacts=dict(),
+            sweep_no_artifacts=dict(),
+            launch_no_artifacts=dict(),
+            artifacts=dict(),
+        )
 
         if not settings.sagemaker_disable and sagemaker.is_using_sagemaker():
             sagemaker_config = sagemaker.parse_sm_config()
-            self._split_artifacts_from_config(sagemaker_config, self.config)
-
-            with telemetry.context(obj=self._init_telemetry_obj) as tel:
-                tel.feature.sagemaker = True
+            self._split_artifacts_from_config(
+                sagemaker_config,
+                config_target=result.base_no_artifacts,
+                artifacts=result.artifacts,
+            )
+            self._telemetry.feature.sagemaker = True
 
         if self._wl._config:
-            self._split_artifacts_from_config(self._wl._config, self.config)
+            self._split_artifacts_from_config(
+                self._wl._config,
+                config_target=result.base_no_artifacts,
+                artifacts=result.artifacts,
+            )
 
         if config and isinstance(config, dict):
-            self._split_artifacts_from_config(config, self.config)
-
-        self.sweep_config = dict()
-        sweep_config = self._wl._sweep_config or dict()
-        if sweep_config:
-            self._split_artifacts_from_config(sweep_config, self.sweep_config)
-
-        if monitor_gym and len(wandb.patched["gym"]) == 0:
-            wandb.gym.monitor()  # type: ignore
-
-        if wandb.patched["tensorboard"]:
-            with telemetry.context(obj=self._init_telemetry_obj) as tel:
-                tel.feature.tensorboard_patch = True
+            self._split_artifacts_from_config(
+                config,
+                config_target=result.base_no_artifacts,
+                artifacts=result.artifacts,
+            )
 
-        if settings.sync_tensorboard:
-            if len(wandb.patched["tensorboard"]) == 0:
-                wandb.tensorboard.patch()  # type: ignore
-            with telemetry.context(obj=self._init_telemetry_obj) as tel:
-                tel.feature.tensorboard_sync = True
+        if self._wl._sweep_config:
+            self._split_artifacts_from_config(
+                self._wl._sweep_config,
+                config_target=result.sweep_no_artifacts,
+                artifacts=result.artifacts,
+            )
 
-        if not settings._noop:
-            self._log_setup(settings)
+        if launch_config := _handle_launch_config(settings):
+            self._split_artifacts_from_config(
+                launch_config,
+                config_target=result.launch_no_artifacts,
+                artifacts=result.artifacts,
+            )
 
-            if settings._jupyter:
-                self._jupyter_setup(settings)
-        launch_config = _handle_launch_config(settings)
-        if launch_config:
-            self._split_artifacts_from_config(launch_config, self.launch_config)
+        return result
 
     def teardown(self) -> None:
         # TODO: currently this is only called on failed wandb.init attempts
@@ -441,11 +464,14 @@ class _WandbInit:
             hook.call()
 
     def _split_artifacts_from_config(
-        self, config_source: dict, config_target: dict
+        self,
+        config_source: dict,
+        config_target: dict,
+        artifacts: dict,
     ) -> None:
         for k, v in config_source.items():
             if _is_artifact_representation(v):
-                self.init_artifact_config[k] = v
+                artifacts[k] = v
             else:
                 config_target.setdefault(k, v)
 
@@ -540,7 +566,7 @@ class _WandbInit:
         ipython.display_pub.publish = ipython.display_pub._orig_publish
         del ipython.display_pub._orig_publish
 
-    def _jupyter_setup(self, settings: Settings) -> None:
+    def monkeypatch_ipython(self, settings: Settings) -> None:
         """Add hooks, and session history saving."""
         self.notebook = wandb.jupyter.Notebook(settings)  # type: ignore
         ipython = self.notebook.shell
@@ -566,7 +592,7 @@ class _WandbInit:
 
         ipython.display_pub.publish = publish
 
-    def _log_setup(self, settings: Settings) -> None:
+    def setup_run_log_directory(self, settings: Settings) -> None:
         """Set up logging from settings."""
         filesystem.mkdir_exists_ok(os.path.dirname(settings.log_user))
         filesystem.mkdir_exists_ok(os.path.dirname(settings.log_internal))
@@ -598,15 +624,18 @@ class _WandbInit:
         self._logger.info(f"Logging user logs to {settings.log_user}")
         self._logger.info(f"Logging internal logs to {settings.log_internal}")
 
-    def _make_run_disabled(self) -> Run:
+    def make_disabled_run(self, config: _ConfigParts) -> Run:
         """Returns a Run-like object where all methods are no-ops.
 
-        This method is used when wandb.init(mode="disabled") is called or WANDB_MODE=disabled
-        is set. It creates a Run object that mimics the behavior of a normal Run but doesn't
+        This method is used when the `mode` setting is set to "disabled", such as
+        by wandb.init(mode="disabled") or by setting the WANDB_MODE environment
+        variable to "disabled".
+
+        It creates a Run object that mimics the behavior of a normal Run but doesn't
         communicate with the W&B servers.
 
-        The returned Run object has all expected attributes and methods, but they are
-        no-op versions that don't perform any actual logging or communication.
+        The returned Run object has all expected attributes and methods, but they
+        are no-op versions that don't perform any actual logging or communication.
         """
         run_id = runid.generate_id()
         drun = Run(
@@ -624,8 +653,8 @@ class _WandbInit:
         )
         # config, summary, and metadata objects
         drun._config = wandb.sdk.wandb_config.Config()
-        drun._config.update(self.sweep_config)
-        drun._config.update(self.config)
+        drun._config.update(config.sweep_no_artifacts)
+        drun._config.update(config.base_no_artifacts)
         drun.summary = SummaryDisabled()  # type: ignore
         drun._Run__metadata = wandb.sdk.wandb_metadata.Metadata()
 
@@ -710,18 +739,17 @@ class _WandbInit:
         percent_done = handle.percent_done
         self.printer.progress_update(line, percent_done=percent_done)
 
-    def init(self, settings: Settings) -> Run:  # noqa: C901
+    def init(self, settings: Settings, config: _ConfigParts) -> Run:  # noqa: C901
         self._logger.info("calling init triggers")
         trigger.call("on_init")
 
         assert self._wl is not None
 
         self._logger.info(
-            f"wandb.init called with sweep_config: {self.sweep_config}\nconfig: {self.config}"
+            f"wandb.init called with sweep_config: {config.sweep_no_artifacts}"
+            f"\nconfig: {config.base_no_artifacts}"
         )
 
-        if settings._noop:
-            return self._make_run_disabled()
         if (
             settings.reinit or (settings._jupyter and settings.reinit is not False)
         ) and len(self._wl._global_run_stack) > 0:
@@ -738,8 +766,11 @@ class _WandbInit:
             latest_run.finish()
         elif wandb.run is not None and os.getpid() == wandb.run._init_pid:
             self._logger.info("wandb.init() called when a run is still active")
+
+            # NOTE: Updates telemetry on the pre-existing run.
             with telemetry.context() as tel:
                 tel.feature.init_return_run = True
+
             return wandb.run
 
         self._logger.info("starting backend")
@@ -765,14 +796,14 @@ class _WandbInit:
 
         # resuming needs access to the server, check server_status()?
         run = Run(
-            config=self.config,
+            config=config.base_no_artifacts,
             settings=settings,
-            sweep_config=self.sweep_config,
-            launch_config=self.launch_config,
+            sweep_config=config.sweep_no_artifacts,
+            launch_config=config.launch_no_artifacts,
         )
 
         # Populate initial telemetry
-        with telemetry.context(run=run, obj=self._init_telemetry_obj) as tel:
+        with telemetry.context(run=run, obj=self._telemetry) as tel:
             tel.cli_version = wandb.__version__
             tel.python_version = platform.python_version()
             tel.platform = f"{platform.system()}-{platform.machine()}".lower()
@@ -873,15 +904,11 @@ class _WandbInit:
 
         run_result: pb.RunUpdateResult | None = None
 
-        if settings._offline:
-            with telemetry.context(run=run) as tel:
-                tel.feature.offline = True
-
-            if settings.resume:
-                wandb.termwarn(
-                    "`resume` will be ignored since W&B syncing is set to `offline`. "
-                    f"Starting a new run with run id {run.id}."
-                )
+        if settings._offline and settings.resume:
+            wandb.termwarn(
+                "`resume` will be ignored since W&B syncing is set to `offline`. "
+                f"Starting a new run with run id {run.id}."
+            )
         error: wandb.Error | None = None
 
         timeout = settings.init_timeout
@@ -970,7 +997,7 @@ class _WandbInit:
         # put artifacts in run config here
         # since doing so earlier will cause an error
         # as the run is not upserted
-        for k, v in self.init_artifact_config.items():
+        for k, v in config.artifacts.items():
             run.config.update({k: v}, allow_val_change=True)
         job_artifact = run._launch_artifact_mapping.get(
             wandb.util.LAUNCH_JOB_ARTIFACT_SLOT_NAME
@@ -1062,6 +1089,26 @@ def _attach(
     return run
 
 
+def _monkeypatch_openai_gym() -> None:
+    """Patch OpenAI gym to log to the global `wandb.run`."""
+    if len(wandb.patched["gym"]) > 0:
+        return
+
+    from wandb.integration import gym
+
+    gym.monitor()
+
+
+def _monkeypatch_tensorboard() -> None:
+    """Patch TensorBoard to log to the global `wandb.run`."""
+    if len(wandb.patched["tensorboard"]) > 0:
+        return
+
+    from wandb.integration import tensorboard as tb_module
+
+    tb_module.patch()
+
+
 def init(  # noqa: C901
     entity: str | None = None,
     project: str | None = None,
@@ -1299,6 +1346,8 @@ def init(  # noqa: C901
     """
     wandb._assert_is_user_process()  # type: ignore
 
+    init_telemetry = telemetry.TelemetryRecord()
+
     init_settings = Settings()
     if isinstance(settings, dict):
         init_settings = Settings(**settings)
@@ -1346,26 +1395,55 @@ def init(  # noqa: C901
     if resume_from is not None:
         init_settings.resume_from = resume_from  # type: ignore
 
+    if config is not None:
+        init_telemetry.feature.set_init_config = True
+
     wl: wandb_setup._WandbSetup | None = None
 
     try:
         wl = wandb.setup()
 
-        wi = _WandbInit(wl)
+        wi = _WandbInit(wl, init_telemetry)
 
         wi.maybe_login(init_settings)
-        run_settings = wi.compute_run_settings(init_settings)
+        run_settings = wi.make_run_settings(init_settings)
+
+        if run_settings.run_id is not None:
+            init_telemetry.feature.set_init_id = True
+        if run_settings.run_name is not None:
+            init_telemetry.feature.set_init_name = True
+        if run_settings.run_tags is not None:
+            init_telemetry.feature.set_init_tags = True
+        if run_settings._offline:
+            init_telemetry.feature.offline = True
+
         wi.set_run_id(run_settings)
 
-        wi.setup(
+        run_config = wi.make_run_config(
             settings=run_settings,
             config=config,
             config_exclude_keys=config_exclude_keys,
             config_include_keys=config_include_keys,
-            monitor_gym=monitor_gym,
         )
 
-        return wi.init(run_settings)
+        if run_settings._noop:
+            return wi.make_disabled_run(run_config)
+
+        wi.setup_run_log_directory(run_settings)
+        if run_settings._jupyter:
+            wi.monkeypatch_ipython(run_settings)
+
+        if monitor_gym:
+            _monkeypatch_openai_gym()
+
+        if wandb.patched["tensorboard"]:
+            # NOTE: The user may have called the patch function directly.
+            init_telemetry.feature.tensorboard_patch = True
+        if run_settings.sync_tensorboard:
+            _monkeypatch_tensorboard()
+            init_telemetry.feature.tensorboard_sync = True
+
+        return wi.init(run_settings, run_config)
 
     except KeyboardInterrupt as e:
         if wl:

wandb/sdk/wandb_run.py

@@ -547,8 +547,6 @@ class Run:
 
     _init_pid: int
     _attach_pid: int
-    _iface_pid: int | None
-    _iface_port: int | None
 
     _attach_id: str | None
     _is_attached: bool
@@ -707,10 +705,6 @@ class Run:
         if launch_trace_id:
             self._config[wandb_key]["launch_trace_id"] = launch_trace_id
 
-        # interface pid and port configured when backend is configured (See _hack_set_run)
-        # TODO: using pid isn't the best for windows as pid reuse can happen more often than unix
-        self._iface_pid = None
-        self._iface_port = None
         self._attach_id = None
         self._is_attached = False
         self._is_finished = False
@@ -721,12 +715,6 @@ class Run:
         if not self._settings.x_disable_service:
             self._attach_id = self._settings.run_id
 
-    def _set_iface_pid(self, iface_pid: int) -> None:
-        self._iface_pid = iface_pid
-
-    def _set_iface_port(self, iface_port: int) -> None:
-        self._iface_port = iface_port
-
     def _handle_launch_artifact_overrides(self) -> None:
         if self._settings.launch and (os.environ.get("WANDB_ARTIFACTS") is not None):
             try:
@@ -1442,6 +1430,7 @@ class Run:
 
         not_using_tensorboard = len(wandb.patched["tensorboard"]) == 0
         self._backend.interface.publish_partial_history(
+            self,
             data,
             user_step=self._step,
             step=step,

{wandb-0.19.3.dist-info → wandb-0.19.4rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.19.3
+Version: 0.19.4rc1
 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

{wandb-0.19.3.dist-info → wandb-0.19.4rc1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 package_readme.md,sha256=XGlaq8rMFcoBb21rCr2d5qeSM79ZI4WslLmXqRimTGQ,4395
-wandb/__init__.py,sha256=6bfGa-Ok_bVjLxHb6qRt7k5PAIsE9vs23fgzlEMhcMo,7234
-wandb/__init__.pyi,sha256=hFQcodH9-eV92-XyoD3DAzwe4MWuOEWnNTRMgGAb1EA,48229
+wandb/__init__.py,sha256=qsquw6I2HK2IwAEscWHFxbCGu11BpUBdCBG0U2CEhWg,7237
+wandb/__init__.pyi,sha256=6uU9MgzzsRUyMvNzJclDzgLOoV8k4a3A7rFl9XSh9l4,48232
 wandb/__main__.py,sha256=uHY6OxHT6RtTH34zC8_UC1GsCTkndgbdsHXv-t7dOMI,67
 wandb/_globals.py,sha256=NwgYSB2tl2Z5t1Tn1xpLtfkcmPy_dF01u-xxgnCbzoc,721
 wandb/data_types.py,sha256=4zXwzPgwHuMjyxzNbVQZANnHM0FoqEOn1jlLvnkdPAc,2342
@@ -49,8 +49,8 @@ wandb/apis/reports/v1/__init__.py,sha256=nxs3gJlbvVc0b_pV5DUypk1amMkRSq_M-xUw7qP
 wandb/apis/reports/v2/__init__.py,sha256=vlF0ZRVHS-Qd7mBllcZri-gWE0TtjhiDSA6h5XPRVLU,271
 wandb/apis/workspaces/__init__.py,sha256=XsF4ccNRUCTmI9ANjlrj_dYU1OcOi5N354Wg2Qkkaqo,273
 wandb/beta/workflows.py,sha256=ENy_lmIyn3k_FHdD2ZO8HBaXdeoLrsPVbEfL_KYW8Ps,10527
-wandb/bin/gpu_stats.exe,sha256=zzNA92_Q82V4yzPtsVFSo6pO4pbeaIox8u6lmftIPNc,8208896
-wandb/bin/wandb-core,sha256=DKT4UChpAdWjIZI6-0sEHCciXO4eAvsGN2ingeOU5SE,47137792
+wandb/bin/gpu_stats.exe,sha256=yDniRlUXftdUm854QGLm1CGM_5adC_2I9RInybhtPig,8364032
+wandb/bin/wandb-core,sha256=Bb1SzRUIyqGh-ABczCxV11XBcJljwNE9IcvHOC1MYNY,47138304
 wandb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wandb/cli/beta.py,sha256=_wbqhk6J2yjnNuVQAGlYbYZ9-j0sFE73zMIXVkQYlXA,5619
 wandb/cli/cli.py,sha256=a3aXT1tAMH5v0_BW1r4Bo6AT2YZ7e1hTz6K4ZnEcz9k,95536
@@ -204,13 +204,13 @@ wandb/sdk/__init__.py,sha256=6lzqckLZUs7GpFZIwpgxGJwJDvhuyo-XCQnSrtZqE1c,850
 wandb/sdk/wandb_alerts.py,sha256=f6ygzuXTDT0IvMLcKlgatmXKx5HMPsm8sYwvPocl0Js,205
 wandb/sdk/wandb_config.py,sha256=TxH6SD8DCfFU3yhmy03yewXQ4Gvgn3avZ0qbwpZJKt8,11178
 wandb/sdk/wandb_helper.py,sha256=kc5Ib648to7cEGEwAuJus07rsHudL1Ux7FWPPSRnKy8,1878
-wandb/sdk/wandb_init.py,sha256=qP1D1HuG0WoEdR0FU34HQA6qNM9i6IPGhV0JeSJef8Q,57867
+wandb/sdk/wandb_init.py,sha256=9j2pDYPBKYdBlI9k8S6yUXe70FnyG60gIcoml3tuGfo,59904
 wandb/sdk/wandb_login.py,sha256=OupHHFIAg-EwP-3jp67rR_dlcFoVd8Qu_J1gtC26p18,11305
 wandb/sdk/wandb_metadata.py,sha256=kcF7MhTM4Cnlw8d5rSp-WzKNDfy2NtUhd8FFuB2i3pY,20658
 wandb/sdk/wandb_metric.py,sha256=oI6NQJJ_tyZ3YcnO0Xg5avDVr3Dh6tpTvHuPEMda30A,3378
 wandb/sdk/wandb_require.py,sha256=06Mgqdd5r5u4UUpIU3T2JIAn0elkFfaWRtNwyaLu8jc,3044
 wandb/sdk/wandb_require_helpers.py,sha256=4PUXmVw86_XaKj3rn20s5DAjBMO8L0m26KqnTLaQJNc,1375
-wandb/sdk/wandb_run.py,sha256=p9uPY-nE6EFhBUsl0jU1xxNijeTSL_1yliDPThfHZNk,159829
+wandb/sdk/wandb_run.py,sha256=GhunOgu-T35PJt8VTLYPv9JFResUPq8m-4q14z-6LOc,159343
 wandb/sdk/wandb_settings.py,sha256=vSRyZPLORsM7Gca-pgQEUNNyo5uNXbm07wkbiNZHGoU,48543
 wandb/sdk/wandb_setup.py,sha256=44YSZ2o_uFGN9cRQOcbwq25EFI5VC8EJOyOLOXGxubs,13417
 wandb/sdk/wandb_summary.py,sha256=eEV3hvHhbc1XQus0MUqFmvhXCzd3SPjvVVVg_fVZ1QM,4686
@@ -280,7 +280,7 @@ wandb/sdk/integration_utils/auto_logging.py,sha256=143120qDwFrh7qsojhMvT4CddgHes
 wandb/sdk/integration_utils/data_logging.py,sha256=DtSEZB-TzxQKhjm9IXNxDeOAUZyDXGYrfRvVh2Cju54,20008
 wandb/sdk/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wandb/sdk/interface/constants.py,sha256=GKZ2hATTBCt7yU8kloafZR34yLChiI36O_VtxZZbQyg,64
-wandb/sdk/interface/interface.py,sha256=MfoJjLujxflUBIGQdfqaAGGLCxlk9PhguLIDgnm1QmE,37636
+wandb/sdk/interface/interface.py,sha256=A-WwyV6qfBYa1v5ik3fGMgKk8Re95NniuCngMqksNAE,37443
 wandb/sdk/interface/interface_queue.py,sha256=RG_FfjVt3arcNSRFXCiwjkleUkpUYJZfUdp5oV-68Is,1753
 wandb/sdk/interface/interface_relay.py,sha256=R28bIhebZux7PwFeJmO8wOOkm_uCjmQ2T5lKKy3sL-Y,1567
 wandb/sdk/interface/interface_shared.py,sha256=f3UH-u_5bI2t_J8EJw1JN8RuTQadLtg8rQafpZlWhq0,21838
@@ -310,7 +310,7 @@ wandb/sdk/internal/sample.py,sha256=tVNzrLatHr8P1kbVzw8bWhLpqZxx7zdm4fgv7rv2hO0,
 wandb/sdk/internal/sender.py,sha256=0ZJ6iGjU1UYwCyQVNzdHU-wyNWbRYvSAZdzfF3RLl74,67023
 wandb/sdk/internal/sender_config.py,sha256=LZaQY4_bzb9003D2j6aynGqv-Mr2GwUGcNmnQrhJOJw,6964
 wandb/sdk/internal/settings_static.py,sha256=jGEP14enXA2A9YiA_EyFzn7OhVGavyuTbr-eVEl8tBk,3767
-wandb/sdk/internal/tb_watcher.py,sha256=FmfAW3TAdYkacgKrlasPnfTI0opOa5XKEC9ld9eg69k,19236
+wandb/sdk/internal/tb_watcher.py,sha256=KRIGZA8gF3guuZm1ioUo8Uy4iOX2OZ3I_MkDW_znh-k,19259
 wandb/sdk/internal/thread_local_settings.py,sha256=f6uzjTa0d6twZ9aFHzdUlUqv3gy6AnbOZoWYm95DxKA,545
 wandb/sdk/internal/writer.py,sha256=D2vQe-2yEfUuGwqYxMvu7iZgo3rpsjUxCgrH8YwNSeA,7471
 wandb/sdk/internal/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -817,8 +817,8 @@ wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/importlib2.py,sha256=kX0rdVmTDL
 wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/platform.py,sha256=7fpTDfxSYvSRtHvyog-plRdLR5A6k1QVY_AL0gVhhPM,1563
 wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/unicode_paths.py,sha256=xzyQmuba2gns1s3Qemu9SXaKV5zeTL3TP9--xOi541g,2254
 wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/win32stat.py,sha256=R48kuuEIi7XzCJBJ6Xo7v6DJIbOP5EwcsWaPf5Axn_g,3951
-wandb-0.19.3.dist-info/METADATA,sha256=e19bSAZtoEB6YW4CHgz1zBmQbw5uKTC88F-KZgBokLg,10282
-wandb-0.19.3.dist-info/WHEEL,sha256=F7luzo77gHneG2SMTaD6iIlqNT8oVz1uotn5Zigp4o8,89
-wandb-0.19.3.dist-info/entry_points.txt,sha256=v4FCOZ9gW7Pc6KLsmgQqpCiKTrA1wh2XHmNf-NUP1-I,67
-wandb-0.19.3.dist-info/licenses/LICENSE,sha256=rJ7p1acqNi17WFOAJ9WqsImXZtKZDA3i_gzdDVGRuFQ,1102
-wandb-0.19.3.dist-info/RECORD,,
+wandb-0.19.4rc1.dist-info/METADATA,sha256=65fpP8edcTSem5od14zJT5b6hP6kjhd5gId96p23QXk,10285
+wandb-0.19.4rc1.dist-info/WHEEL,sha256=F7luzo77gHneG2SMTaD6iIlqNT8oVz1uotn5Zigp4o8,89
+wandb-0.19.4rc1.dist-info/entry_points.txt,sha256=v4FCOZ9gW7Pc6KLsmgQqpCiKTrA1wh2XHmNf-NUP1-I,67
+wandb-0.19.4rc1.dist-info/licenses/LICENSE,sha256=rJ7p1acqNi17WFOAJ9WqsImXZtKZDA3i_gzdDVGRuFQ,1102
+wandb-0.19.4rc1.dist-info/RECORD,,