wandb 0.19.3__py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.19.4rc1__py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.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.4
 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,17 +1,12 @@
 package_readme.md,sha256=U9047nyMDICgctm1HLm4HfXwFnFKsEn2m77hsYPUZ1I,4298
-wandb-0.19.3.dist-info/WHEEL,sha256=fTf-veJdTwcKkwyiHTvgNV2L-0jwiK0w7ozo8ARrNAg,143
-wandb-0.19.3.dist-info/METADATA,sha256=AGD2Iwy-cUjmtannnNpN4Nh9wQAjRZw7WgFow2-DvwI,10282
-wandb-0.19.3.dist-info/RECORD,,
-wandb-0.19.3.dist-info/entry_points.txt,sha256=v4FCOZ9gW7Pc6KLsmgQqpCiKTrA1wh2XHmNf-NUP1-I,67
-wandb-0.19.3.dist-info/licenses/LICENSE,sha256=izOKRJpGOx1PrJiGOKR0HsNdlB5JdH2d0Z4P7a7ssTc,1081
 wandb/wandb_controller.py,sha256=SksJdgwn14PpnUoIaBjJ9Ki4Nksl9BpQGGn42hT0xZg,24936
 wandb/jupyter.py,sha256=ip6ukYdoFzvPiHO-IUNnbMMxRnYl3ebEoC0X143_VEw,17274
 wandb/wandb_run.py,sha256=CNh9S6uubFk8FphQjzkbvedyyGCN9aBEsRBKjy8tqqs,155
 wandb/trigger.py,sha256=PaitU3sX6ekGkd2R8iD6d_VtI72ypF7LaPBXh3rXY7Q,615
 wandb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wandb/__main__.py,sha256=gripuDgB7J8wMMeJt4CIBRjn1BMSFr5zvsrt585Pnj4,64
-wandb/__init__.py,sha256=5f1_Sih9Sxjo5YN6UOofmcFjW0XnL5FxgWk-saYyMhw,6988
-wandb/__init__.pyi,sha256=__KjZYDXGiHshy_OUrsV7chJrIiOon8DuzRjM6ubHnc,47024
+wandb/__init__.py,sha256=amlCK5n_1hyN1-MkgQ3CWpMhvrRq-X8B9Q4iZemjWzY,6991
+wandb/__init__.pyi,sha256=nZ_mrCwelWNIQBbhGrJ1cKX8z_IfihKjoMc3ByY0loM,47027
 wandb/sklearn.py,sha256=hbPkefhS39A1RRymn0nHZZmKM2TrOd4xjlkthTZe9pY,803
 wandb/wandb_agent.py,sha256=0TKjcJ8jxEqaXMrs_dIflXfWFFOaulfSjzp_fpYiXD0,20985
 wandb/env.py,sha256=ImVRezUi1wpXf2ogJ4IY9YNaELqon3k3S6-vCMNNzwQ,13505
@@ -29,7 +24,7 @@ wandb/analytics/__init__.py,sha256=WG_Mh20Hr8d3vDmGMcfDXCMEIew3uzDYZAJwFsrbAug,5
 wandb/sdk/wandb_metric.py,sha256=a3GiQXr6H18m81uobYjlJaC8CL8iANzI42qxkxfZsDs,3268
 wandb/sdk/wandb_sync.py,sha256=GmIjtydDNiUT3FHkrFcIZzSlqiRerXA8kY3q72ZbL1k,2275
 wandb/sdk/wandb_settings.py,sha256=gXZydMDYH8OLcAoK78mA4naRqBA2aKlsIGKn3i4OC0s,47290
-wandb/sdk/wandb_run.py,sha256=eI6WIi2pmkBkP5aMgscMU9C94PjGVknEYQvVPlC-YDM,155668
+wandb/sdk/wandb_run.py,sha256=Jk-KLMtrjX698iUCT2gjivutfR01ud9DjnuSiuVYop8,155193
 wandb/sdk/wandb_require.py,sha256=Y0ib8h27__t7hXos1F2srfsQzVfzH4BB6wq8E1aRbRA,2950
 wandb/sdk/wandb_require_helpers.py,sha256=ZmKv5aXXHDTTU6nYHMLKW4_pt9X-PlaMtbRJl77kHX8,1331
 wandb/sdk/wandb_metadata.py,sha256=nT6TUF4Yh-ka3VQGyKd3y9MTEHJUgRVT4ICyfJkbHFo,20111
@@ -39,7 +34,7 @@ wandb/sdk/wandb_sweep.py,sha256=Sg_JqxVzmjUBvii41azpdr-c6RPwHOBnSha8k7jrRhk,4028
 wandb/sdk/wandb_config.py,sha256=b7kxQVnIh5HCBZXb2pOGZ4c02xCVlW4IQiAu3N-8Opg,10856
 wandb/sdk/wandb_watch.py,sha256=F7S9CLbw9PddUp1qBjPRKsOiVFU8LPaq6A9taV3TJKI,4840
 wandb/sdk/wandb_helper.py,sha256=IbJ7opO8UkfwCDekSjRYIrGBblUxnTPBfp1EdesfF4U,1824
-wandb/sdk/wandb_init.py,sha256=z19KqQWjmOcnswowWoq4VAHGalTmjLKwz1R-Rm1i-Bo,56484
+wandb/sdk/wandb_init.py,sha256=XqlUH5OpIdyatgTKHMIsDM3xUSwVbgl_zFzezB8xOg8,58443
 wandb/sdk/wandb_login.py,sha256=DP7nDUGx2UmqGRBrvTmcpvzRBVeRD0qEENtmu4sjDAQ,10966
 wandb/sdk/wandb_setup.py,sha256=7j3UBiqm8x7f4JsFPX5jR19wNRSRvf77TIyncd0HpJg,13014
 wandb/sdk/wandb_summary.py,sha256=yQdOVIPrZaZanhBQ7yuSfPLX0x6dxwkN_KAn4SgjSZU,4536
@@ -128,7 +123,7 @@ wandb/sdk/internal/progress.py,sha256=9nNAErIXzJoapctsfqWYhESNPzFkXAu5TVAnaKsIa4
 wandb/sdk/internal/file_pusher.py,sha256=clBm6fj_27krGVCcFw9mUdalXHRZlIUxsj5AW_BAzZU,6098
 wandb/sdk/internal/flow_control.py,sha256=3LJ-KatyPPH18G7TfSMLDk-BE5tankB4JRhQqLoUOWM,8585
 wandb/sdk/internal/run.py,sha256=8OhVy2vfgPC8pNFq0tJ4CkQHETOBfQsFDghw50ccSXc,682
-wandb/sdk/internal/tb_watcher.py,sha256=MpHESnP4UpTq24GnYcBrF1csupFzCVL4dET-f4dj-98,18717
+wandb/sdk/internal/tb_watcher.py,sha256=3AvQGlZLGkr8POhaSGzbeyIcX0YWkLkblJ0bksAB8U8,18738
 wandb/sdk/internal/context.py,sha256=dnmsKEoQ2xOtmXM5OBVHdyGO3XdTQrqjxfb1lRADSTc,2518
 wandb/sdk/internal/file_stream.py,sha256=Dnqayrbqa6L2sG03rX2oIFhWT-IME5vl5JTykyLFMNY,25866
 wandb/sdk/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -160,7 +155,7 @@ wandb/sdk/internal/system/assets/tpu.py,sha256=nwv3C9a6dgD1hc0461Rh28NQkWbNQ5fJO
 wandb/sdk/internal/system/assets/gpu.py,sha256=DnnfH9fvvfiRXzMAXjCgHZZZt_Kkn2br74T3Y_oyyhw,13722
 wandb/sdk/internal/system/assets/aggregators.py,sha256=EzJp_YjvYORcBH6g58OsqGtmy55HqYHYMAvaIsp2Iwg,1093
 wandb/sdk/internal/system/assets/trainium.py,sha256=YlWnRf5fAxEqkAnHQ0iGZo2phvD-QTOAuYyO0PaJYJg,13346
-wandb/sdk/interface/interface.py,sha256=-q9mxz8RpHz5_UNKT91sP7w5sOqEFQKkY2B4teLe2vM,36626
+wandb/sdk/interface/interface.py,sha256=coqmzkIQr8s_hzryIhID__5JHw-waMkE65ICv1KcFMQ,36439
 wandb/sdk/interface/router_relay.py,sha256=uf0KA_WJ25xMwLsH_3RU_ZhRPNS5qujo1aFU2d_rfzs,953
 wandb/sdk/interface/message_future_poll.py,sha256=drjrcBKswYPYJJQLFlj7UDXq7_zg7KNcObFVetsbvhQ,1410
 wandb/sdk/interface/router.py,sha256=uTgmF0TaQnYq8Frgs7pncUBucA6B7XXCmKcRoYEZV10,3419
@@ -257,7 +252,7 @@ wandb/sdk/service/server_sock.py,sha256=lpeVRPI0ehRZHoNyG0dCGmBdLnlv_Xl1Znf4qqZH
 wandb/sdk/service/streams.py,sha256=DR7vtHV0q4rBMGJwnS-mYoOfHix9IS8knpWrCIKNv1g,14642
 wandb/sdk/service/server.py,sha256=_0MAn4Y1hs2AnapyQb5heYiixKQNxFENfkxIGoiiIB8,3460
 wandb/sdk/service/_startup_debug.py,sha256=A6P5iCYRoNGcVulziUc7Mw_Y2MCG8PAIAUVjzzMUTPs,602
-wandb/bin/wandb-core,sha256=TEw0Mkz0w190K56hxK1facc9zmrHBp7k07CxA_66Cyg,43909272
+wandb/bin/wandb-core,sha256=rTdTl9hrTITHO36-nN4A7W7I9vdvHfTU1iWjSttM9n0,43909272
 wandb/bin/gpu_stats,sha256=gmMeMCUk-CATuVr6fK0ipPGnIaMIVcovrxuhBal-rnI,11022064
 wandb/proto/wandb_generate_proto.py,sha256=KO1hlAUBGHQRNKsddhcSXvh5a6rmFM3kshKTWftbWwY,1278
 wandb/proto/wandb_generate_deprecated.py,sha256=Iyf7PwIL_2B7XohrckYLbjjT09lccwbqknxtWelJpJM,1002
@@ -822,3 +817,8 @@ wandb/docker/__init__.py,sha256=zaXUYlTQLBJo8YlxbL3kh0NBHqtXFHNg4-_TNV_WDBs,1059
 wandb/docker/wandb-entrypoint.sh,sha256=P4eTMG7wYsgTfJIws_HT7QFlYBI70ZLnNlDGTZdmYVE,989
 wandb/docker/www_authenticate.py,sha256=eQd0ap8LpZkS9ImRn2gdgl7gnHeKprdqjClrZOaCsQo,2805
 wandb/docker/auth.py,sha256=Tr-BMoiMJjX8TsdUquVBBLyfxEJWR4WQZGyz6vBaJk0,15009
+wandb-0.19.4rc1.dist-info/WHEEL,sha256=fTf-veJdTwcKkwyiHTvgNV2L-0jwiK0w7ozo8ARrNAg,143
+wandb-0.19.4rc1.dist-info/METADATA,sha256=uyIurAspZwmJRHUtzVckSZv375aN1Lpvi7IqLuCgMbc,10285
+wandb-0.19.4rc1.dist-info/RECORD,,
+wandb-0.19.4rc1.dist-info/entry_points.txt,sha256=v4FCOZ9gW7Pc6KLsmgQqpCiKTrA1wh2XHmNf-NUP1-I,67
+wandb-0.19.4rc1.dist-info/licenses/LICENSE,sha256=izOKRJpGOx1PrJiGOKR0HsNdlB5JdH2d0Z4P7a7ssTc,1081