wandb 0.19.3__py3-none-win32.whl → 0.19.4__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.4"
 
 
 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.4"
 
 run: Run | None
 config: wandb_config.Config

wandb/sdk/backend/backend.py

@@ -25,8 +25,6 @@ if TYPE_CHECKING:
     from wandb.proto.wandb_internal_pb2 import Record, Result
     from wandb.sdk.lib import service_connection
 
-    from ..wandb_run import Run
-
     RecordQueue = Union["queue.Queue[Record]", multiprocessing.Queue[Record]]
     ResultQueue = Union["queue.Queue[Result]", multiprocessing.Queue[Result]]
 
@@ -54,7 +52,7 @@ class Backend:
     interface: Optional[InterfaceBase]
     _internal_pid: Optional[int]
     wandb_process: Optional[multiprocessing.process.BaseProcess]
-    _settings: Optional[Settings]
+    _settings: Settings
     record_q: Optional["RecordQueue"]
     result_q: Optional["ResultQueue"]
     _mailbox: Mailbox
@@ -62,7 +60,7 @@ class Backend:
     def __init__(
         self,
         mailbox: Mailbox,
-        settings: Optional[Settings] = None,
+        settings: Settings,
         log_level: Optional[int] = None,
         service: "Optional[service_connection.ServiceConnection]" = None,
     ) -> None:
@@ -84,12 +82,7 @@ class Backend:
         self._save_mod_path: Optional[str] = None
         self._save_mod_spec = None
 
-    def _hack_set_run(self, run: "Run") -> None:
-        assert self.interface
-        self.interface._hack_set_run(run)
-
     def _multiprocessing_setup(self) -> None:
-        assert self._settings
         if self._settings.start_method == "thread":
             return
 
@@ -141,10 +134,13 @@ class Backend:
     def ensure_launched(self) -> None:
         """Launch backend worker if not running."""
         if self._service:
-            self.interface = self._service.make_interface(self._mailbox)
+            assert self._settings.run_id
+            self.interface = self._service.make_interface(
+                self._mailbox,
+                stream_id=self._settings.run_id,
+            )
             return
 
-        assert self._settings
         settings = self._settings.model_copy()
         settings.x_log_level = self._log_level or logging.DEBUG
 

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
@@ -91,18 +90,11 @@ def file_enum_to_policy(enum: "pb.FilesItem.PolicyType.V") -> "PolicyName":
 
 
 class InterfaceBase:
-    _run: Optional["Run"]
     _drop: bool
 
     def __init__(self) -> None:
-        self._run = None
         self._drop = False
 
-    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()
         self._publish_header(header)
@@ -235,7 +227,12 @@ class InterfaceBase:
             update.value_json = json.dumps(v)
         return summary
 
-    def _summary_encode(self, value: Any, path_from_root: str) -> dict:
+    def _summary_encode(
+        self,
+        value: Any,
+        path_from_root: str,
+        run: "Run",
+    ) -> dict:
         """Normalize, compress, and encode sub-objects for backend storage.
 
         value: Object to encode.
@@ -253,12 +250,14 @@ class InterfaceBase:
             json_value = {}
             for key, value in value.items():  # noqa: B020
                 json_value[key] = self._summary_encode(
-                    value, path_from_root + "." + key
+                    value,
+                    path_from_root + "." + key,
+                    run=run,
                 )
             return json_value
         else:
             friendly_value, converted = json_friendly(
-                val_to_json(self._run, path_from_root, value, namespace="summary")
+                val_to_json(run, path_from_root, value, namespace="summary")
             )
             json_value, compressed = maybe_compress_summary(
                 friendly_value, get_h5_typename(value)
@@ -270,7 +269,11 @@ class InterfaceBase:
 
             return json_value
 
-    def _make_summary(self, summary_record: sr.SummaryRecord) -> pb.SummaryRecord:
+    def _make_summary(
+        self,
+        summary_record: sr.SummaryRecord,
+        run: "Run",
+    ) -> pb.SummaryRecord:
         pb_summary_record = pb.SummaryRecord()
 
         for item in summary_record.update:
@@ -285,7 +288,11 @@ class InterfaceBase:
                 pb_summary_item.key = item.key[0]
 
             path_from_root = ".".join(item.key)
-            json_value = self._summary_encode(item.value, path_from_root)
+            json_value = self._summary_encode(
+                item.value,
+                path_from_root,
+                run=run,
+            )
             json_value, _ = json_friendly(json_value)  # type: ignore
 
             pb_summary_item.value_json = json.dumps(
@@ -306,8 +313,12 @@ class InterfaceBase:
 
         return pb_summary_record
 
-    def publish_summary(self, summary_record: sr.SummaryRecord) -> None:
-        pb_summary_record = self._make_summary(summary_record)
+    def publish_summary(
+        self,
+        run: "Run",
+        summary_record: sr.SummaryRecord,
+    ) -> None:
+        pb_summary_record = self._make_summary(summary_record, run=run)
         self._publish_summary(pb_summary_record)
 
     @abstractmethod
@@ -653,15 +664,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 +697,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/interface/interface_sock.py

@@ -16,32 +16,28 @@ from .router_sock import MessageSockRouter
 if TYPE_CHECKING:
     from wandb.proto import wandb_internal_pb2 as pb
 
-    from ..wandb_run import Run
-
 
 logger = logging.getLogger("wandb")
 
 
 class InterfaceSock(InterfaceShared):
-    _stream_id: Optional[str]
-    _sock_client: SockClient
     _mailbox: Mailbox
 
-    def __init__(self, sock_client: SockClient, mailbox: Mailbox) -> None:
+    def __init__(
+        self,
+        sock_client: SockClient,
+        mailbox: Mailbox,
+        stream_id: str,
+    ) -> None:
         # _sock_client is used when abstract method _init_router() is called by constructor
         self._sock_client = sock_client
         super().__init__(mailbox=mailbox)
         self._process_check = False
-        self._stream_id = None
+        self._stream_id = stream_id
 
     def _init_router(self) -> None:
         self._router = MessageSockRouter(self._sock_client, mailbox=self._mailbox)
 
-    def _hack_set_run(self, run: "Run") -> None:
-        super()._hack_set_run(run)
-        assert run._settings.run_id
-        self._stream_id = run._settings.run_id
-
     def _assign(self, record: Any) -> None:
         assert self._stream_id
         record._info.stream_id = self._stream_id

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/lib/service_connection.py

@@ -124,9 +124,9 @@ class ServiceConnection:
         self._torn_down = False
         self._cleanup = cleanup
 
-    def make_interface(self, mailbox: Mailbox) -> InterfaceBase:
+    def make_interface(self, mailbox: Mailbox, stream_id: str) -> InterfaceBase:
         """Returns an interface for communicating with the service."""
-        return InterfaceSock(self._client, mailbox)
+        return InterfaceSock(self._client, mailbox, stream_id=stream_id)
 
     def send_record(self, record: pb.Record) -> None:
         """Sends data to the service."""

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()
@@ -860,7 +891,6 @@ class _WandbInit:
         run._set_backend(backend)
         run._set_teardown_hooks(self._teardown_hooks)
 
-        backend._hack_set_run(run)
         assert backend.interface
         mailbox.enable_keepalive()
         backend.interface.publish_header()
@@ -873,15 +903,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 +996,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
@@ -1042,7 +1068,6 @@ def _attach(
         run._init(settings=settings)
     run._set_library(_wl)
     run._set_backend(backend)
-    backend._hack_set_run(run)
     assert backend.interface
 
     mailbox.enable_keepalive()
@@ -1062,6 +1087,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 +1344,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 +1393,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:
@@ -1327,7 +1315,7 @@ class Run:
         with telemetry.context(run=self) as tel:
             tel.feature.set_summary = True
         if self._backend and self._backend.interface:
-            self._backend.interface.publish_summary(summary_record)
+            self._backend.interface.publish_summary(self, summary_record)
 
     def _on_progress_get_summary(self, handle: MailboxProgress) -> None:
         pass
@@ -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.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.19.3
+Version: 0.19.4
 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.4.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=ZVmzUcZ962nd9h4fpfBUnSwssMkS66UsZK4HWbsahsQ,7234
+wandb/__init__.pyi,sha256=Ai5J-LqGFb0ETs856XKkahDDnv9WCSsZWR4dCCJNkLc,48229
 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=wJKvNTStr6_5syn7XCyxEm03CGMM3uxCgUYWATxCncg,8364032
+wandb/bin/wandb-core,sha256=fHT6yuKqrxNZYFLwZHenr4CeNeyrnaMgrVQB3jJfNkU,47137792
 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=5gyJeRd4ya9nSd7LzdqmGnOOO_5ePwZASI1cyuZv-7M,59836
 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=N32b7eT3kn2wO4ERJ5-3KrWHLAzK6k5leWyharlrFX0,159349
 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
@@ -249,7 +249,7 @@ wandb/sdk/artifacts/storage_policies/__init__.py,sha256=G8quZY8-eynVVXmNBbiLGfUo
 wandb/sdk/artifacts/storage_policies/register.py,sha256=azfof-H42vIuvndo9hvN4cZ3UXWG-nZcrFQ1QFL9oIc,50
 wandb/sdk/artifacts/storage_policies/wandb_storage_policy.py,sha256=4nQNkDfG_2Uq4ANOYZIaQVcPsZsUmhs6c2MdQBOqMSI,14380
 wandb/sdk/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wandb/sdk/backend/backend.py,sha256=1o4zCs8suzQsAzBhd-hWp0zTH8lzZ7hqZ-JT8Own1H0,7834
+wandb/sdk/backend/backend.py,sha256=7xJvW0ZpIQkI1TkeO-K9b5kHIypQMjp8WNpS_8Nu0wM,7709
 wandb/sdk/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wandb/sdk/data_types/_dtypes.py,sha256=JYi0cqF2Lska0JF_gndyz-FfcS09Ozu735WIarU8HKo,31010
 wandb/sdk/data_types/_private.py,sha256=vpatnpMcuWUtpSI-dY-YXs9zmffAgEXCoViIGS4yVT8,309
@@ -280,11 +280,11 @@ 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=PW31FI6U735n55mLKHm0WAJ1EgUqQv56nSEvwEguyPo,37594
 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
-wandb/sdk/interface/interface_sock.py,sha256=Tle-Pu5Z1ECQnm47ra1DQ0mdxkqMmJ2atknvTlmqfnE,2063
+wandb/sdk/interface/interface_sock.py,sha256=IQCznD4EH5tcGWPg0XUvFa67-N8AzUiqf6TEoXmQxfc,1859
 wandb/sdk/interface/message_future.py,sha256=SlMF8psfA1AW3iVuB_PVLo41bC4U-AAvek1Zlh31mdE,712
 wandb/sdk/interface/message_future_poll.py,sha256=8a7GcNtCyohHUnxoJ5sx6RRQa2Vu_hjiBqeQ-UQ0RTc,1460
 wandb/sdk/interface/router.py,sha256=ur0vqGqzUi-nafh-4KVHOk71DaqiHJnIWFUQjttQ724,3534
@@ -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
@@ -415,7 +415,7 @@ wandb/sdk/lib/retry.py,sha256=2h1AB9xzNth93ADYJ2g1zlUcmjcEd-bp6UoZAvs5_Yg,10381
 wandb/sdk/lib/run_moment.py,sha256=Bb45CL_loDGwoGkg550lFomDOKJog9CVpaZhqdmNgcc,2265
 wandb/sdk/lib/runid.py,sha256=rHYRTjJu8gTZ6Aoo0WZ5jQfAtNLXQo6aY6PD-i3Fh6I,404
 wandb/sdk/lib/server.py,sha256=ArqpZ-N7EWqNhkXE9E3IDe4N40oJBNwGXhHpI5yGcTs,1148
-wandb/sdk/lib/service_connection.py,sha256=NlyOKENZz6m4sSue76NjzYuuMcW0CHzh4BGyamICYvs,6683
+wandb/sdk/lib/service_connection.py,sha256=BKEgLzFczBcrt0igWS7rf7StE4LcbREZPMuOAJsT7po,6720
 wandb/sdk/lib/service_token.py,sha256=GC8onzk44uphA5l5hHs8RZmQ7Auo7-Dx-KhCWOFYH9g,2565
 wandb/sdk/lib/sock_client.py,sha256=K0gIbhFkW7qkPuPDx-AG4cd08HnDCz9Bp_M99zI34BA,10641
 wandb/sdk/lib/sparkline.py,sha256=CivfHHGPrbnnacpfjsoYUrCtX6Xz7AHoybEeOuWeEI0,1407
@@ -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.4.dist-info/METADATA,sha256=10dH1p2yO5OYXIgbRV3xBDgpAsx6LOzXK0OfzrBIsBs,10282
+wandb-0.19.4.dist-info/WHEEL,sha256=F7luzo77gHneG2SMTaD6iIlqNT8oVz1uotn5Zigp4o8,89
+wandb-0.19.4.dist-info/entry_points.txt,sha256=v4FCOZ9gW7Pc6KLsmgQqpCiKTrA1wh2XHmNf-NUP1-I,67
+wandb-0.19.4.dist-info/licenses/LICENSE,sha256=rJ7p1acqNi17WFOAJ9WqsImXZtKZDA3i_gzdDVGRuFQ,1102
+wandb-0.19.4.dist-info/RECORD,,