wandb 0.21.3__py3-none-win_amd64.whl → 0.22.0__py3-none-win_amd64.whl

wandb/sdk/lib/printer.py

@@ -156,14 +156,10 @@ class Printer(abc.ABC):
         """
 
     @abc.abstractmethod
-    def progress_close(self, text: str | None = None) -> None:
+    def progress_close(self) -> None:
         """Close the progress indicator.
 
         After this, `progress_update` should not be used.
-
-        Args:
-            text: The final text to set on the progress indicator.
-                Ignored in Jupyter notebooks.
         """
 
     @staticmethod
@@ -342,13 +338,10 @@ class _PrinterTerm(Printer):
         wandb.termlog(f"{next(self._progress)} {text}", newline=False)
 
     @override
-    def progress_close(self, text: str | None = None) -> None:
+    def progress_close(self) -> None:
         if self._settings and self._settings.silent:
             return
 
-        text = text or " " * 79
-        wandb.termlog(text)
-
     @property
     @override
     def supports_html(self) -> bool:
@@ -462,11 +455,14 @@ class _PrinterJupyter(Printer):
             display_id=True,
         )
 
-        if handle:
+        if not handle:
+            yield None
+            return
+
+        try:
             yield _DynamicJupyterText(handle)
+        finally:
             handle.update(self._ipython_display.HTML(""))
-        else:
-            yield None
 
     @override
     def display(
@@ -539,7 +535,7 @@ class _PrinterJupyter(Printer):
         self._progress.update(percent_done, text)
 
     @override
-    def progress_close(self, text: str | None = None) -> None:
+    def progress_close(self) -> None:
         if self._progress:
             self._progress.close()
 

wandb/sdk/lib/progress.py

@@ -70,12 +70,14 @@ def progress_printer(
         default_text: The text to show if no information is available.
     """
     with printer.dynamic_text() as text_area:
-        yield ProgressPrinter(
-            printer,
-            text_area,
-            default_text=default_text,
-        )
-        printer.progress_close()
+        try:
+            yield ProgressPrinter(
+                printer,
+                text_area,
+                default_text=default_text,
+            )
+        finally:
+            printer.progress_close()
 
 
 class ProgressPrinter:

wandb/sdk/lib/service/service_connection.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import atexit
+import pathlib
 from typing import Callable
 
 from wandb.proto import wandb_server_pb2 as spb
-from wandb.proto import wandb_settings_pb2
+from wandb.proto import wandb_settings_pb2, wandb_sync_pb2
 from wandb.sdk import wandb_settings
 from wandb.sdk.interface.interface import InterfaceBase
 from wandb.sdk.interface.interface_sock import InterfaceSock
@@ -12,6 +13,7 @@ from wandb.sdk.lib import asyncio_manager
 from wandb.sdk.lib.exit_hooks import ExitHooks
 from wandb.sdk.lib.service.service_client import ServiceClient
 from wandb.sdk.mailbox import HandleAbandonedError, MailboxClosedError
+from wandb.sdk.mailbox.mailbox_handle import MailboxHandle
 
 from . import service_process, service_token
 
@@ -96,6 +98,45 @@ class ServiceConnection:
         """Returns an interface for communicating with the service."""
         return InterfaceSock(self._client, stream_id=stream_id)
 
+    def init_sync(
+        self,
+        paths: set[pathlib.Path],
+        settings: wandb_settings.Settings,
+    ) -> MailboxHandle[wandb_sync_pb2.ServerInitSyncResponse]:
+        """Send a ServerInitSyncRequest."""
+        init_sync = wandb_sync_pb2.ServerInitSyncRequest(
+            path=(str(path) for path in paths),
+            settings=settings.to_proto(),
+        )
+        request = spb.ServerRequest(init_sync=init_sync)
+
+        handle = self._client.deliver(request)
+        return handle.map(lambda r: r.init_sync_response)
+
+    def sync(
+        self,
+        id: str,
+        *,
+        parallelism: int,
+    ) -> MailboxHandle[wandb_sync_pb2.ServerSyncResponse]:
+        """Send a ServerSyncRequest."""
+        sync = wandb_sync_pb2.ServerSyncRequest(id=id, parallelism=parallelism)
+        request = spb.ServerRequest(sync=sync)
+
+        handle = self._client.deliver(request)
+        return handle.map(lambda r: r.sync_response)
+
+    def sync_status(
+        self,
+        id: str,
+    ) -> MailboxHandle[wandb_sync_pb2.ServerSyncStatusResponse]:
+        """Send a ServerSyncStatusRequest."""
+        sync_status = wandb_sync_pb2.ServerSyncStatusRequest(id=id)
+        request = spb.ServerRequest(sync_status=sync_status)
+
+        handle = self._client.deliver(request)
+        return handle.map(lambda r: r.sync_status_response)
+
     def inform_init(
         self,
         settings: wandb_settings_pb2.Settings,
@@ -143,17 +184,6 @@ class ServiceConnection:
         else:
             return response.inform_attach_response.settings
 
-    def inform_start(
-        self,
-        settings: wandb_settings_pb2.Settings,
-        run_id: str,
-    ) -> None:
-        """Send a start request to the service."""
-        request = spb.ServerInformStartRequest()
-        request.settings.CopyFrom(settings)
-        request._info.stream_id = run_id
-        self._client.publish(spb.ServerRequest(inform_start=request))
-
     def teardown(self, exit_code: int) -> int | None:
         """Close the connection.
 

wandb/sdk/mailbox/wait_with_progress.py

@@ -62,7 +62,7 @@ def wait_all_with_progress(
     start_time = time.monotonic()
 
     async def progress_loop_with_timeout() -> list[_T]:
-        with asyncio_compat.cancel_on_exit(display_progress()):
+        async with asyncio_compat.cancel_on_exit(display_progress()):
             if timeout is not None:
                 elapsed_time = time.monotonic() - start_time
                 remaining_timeout = timeout - elapsed_time

wandb/sdk/wandb_init.py

@@ -839,6 +839,13 @@ class _WandbInit:
                     " and reinit is set to 'create_new', so continuing"
                 )
 
+            elif settings.resume == "must":
+                raise wandb.Error(
+                    "Cannot resume a run while another run is active."
+                    " You must either finish it using run.finish(),"
+                    " or use reinit='create_new' when calling wandb.init()."
+                )
+
             else:
                 run_printer.display(
                     "wandb.init() called while a run is active and reinit is"
@@ -864,7 +871,6 @@ class _WandbInit:
         backend.ensure_launched()
         self._logger.info("backend started and connected")
 
-        # resuming needs access to the server, check server_status()?
         run = Run(
             config=config.base_no_artifacts,
             settings=settings,
@@ -1009,14 +1015,6 @@ class _WandbInit:
         run._set_run_obj(result.run_result.run)
 
         self._logger.info("starting run threads in backend")
-        # initiate run (stats and metadata probing)
-
-        if service:
-            assert settings.run_id
-            service.inform_start(
-                settings=settings.to_proto(),
-                run_id=settings.run_id,
-            )
 
         assert backend.interface
 
@@ -1027,6 +1025,8 @@ class _WandbInit:
         except TimeoutError:
             pass
 
+        backend.interface.publish_probe_system_info()
+
         assert self._wl is not None
         self.run = run
 

wandb/sdk/wandb_run.py

@@ -892,7 +892,19 @@ class Run:
     def tags(self, tags: Sequence) -> None:
         with telemetry.context(run=self) as tel:
             tel.feature.set_run_tags = True
-        self._settings.run_tags = tuple(tags)
+
+        try:
+            self._settings.run_tags = tuple(tags)
+        except ValueError as e:
+            # For runtime tag setting, warn instead of crash
+            # Extract the core error message without the pydantic wrapper
+            error_msg = str(e)
+            if "Value error," in error_msg:
+                # Extract the actual error message after "Value error, "
+                error_msg = error_msg.split("Value error, ")[1].split(" [type=")[0]
+            wandb.termwarn(f"Invalid tag detected: {error_msg} Tags not updated.")
+            return
+
         if self._backend and self._backend.interface:
             self._backend.interface.publish_run(self)
 

wandb/sdk/wandb_settings.py

@@ -1435,6 +1435,61 @@ class Settings(BaseModel, validate_assignment=True):
             raise UsageError("Sweep ID cannot contain only whitespace")
         return value
 
+    @field_validator("run_tags", mode="before")
+    @classmethod
+    def validate_run_tags(cls, value):
+        """Validate run tags.
+
+        Validates that each tag:
+        - Is between 1 and 64 characters in length (inclusive)
+        - Converts single string values to tuple format
+        - Preserves None values
+
+        Args:
+            value: A string, list, tuple, or None representing tags
+
+        Returns:
+            tuple: A tuple of validated tags, or None
+
+        Raises:
+            ValueError: If any tag is empty or exceeds 64 characters
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
+        if value is None:
+            return None
+
+        # Convert to tuple if needed
+        if isinstance(value, str):
+            tags = (value,)
+        else:
+            tags = tuple(value)
+
+        # Validate each tag and accumulate errors
+        errors = []
+        for i, tag in enumerate(tags):
+            tag_str = str(tag)
+            if len(tag_str) == 0:
+                errors.append(
+                    f"Tag at index {i} is empty. Tags must be between 1 and 64 characters"
+                )
+            elif len(tag_str) > 64:
+                # Truncate long tags for display
+                display_tag = (
+                    f"{tag_str[:20]}...{tag_str[-20:]}"
+                    if len(tag_str) > 43
+                    else tag_str
+                )
+                errors.append(
+                    f"Tag '{display_tag}' is {len(tag_str)} characters. Tags must be between 1 and 64 characters"
+                )
+
+        # Raise combined error if any validation issues were found
+        if errors:
+            raise ValueError("; ".join(errors))
+
+        return tags
+
     @field_validator("sweep_param_path", mode="before")
     @classmethod
     def validate_sweep_param_path(cls, value):

wandb/wandb_agent.py

@@ -42,11 +42,42 @@ class AgentProcess:
         if command:
             if platform.system() == "Windows":
                 kwargs = dict(creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
+                env.pop(wandb.env.SERVICE, None)
+                # TODO: Determine if we need the same stdin workaround as POSIX case below.
+                self._popen = subprocess.Popen(command, env=env, **kwargs)
             else:
-                kwargs = dict(preexec_fn=os.setpgrp)
-            if env.get(wandb.env.SERVICE):
-                env.pop(wandb.env.SERVICE)
-            self._popen = subprocess.Popen(command, env=env, **kwargs)
+                if sys.version_info >= (3, 11):
+                    # preexec_fn=os.setpgrp is not thread-safe; process_group was introduced in
+                    # python 3.11 to replace it, so use that when possible
+                    kwargs = dict(process_group=0)
+                else:
+                    kwargs = dict(preexec_fn=os.setpgrp)
+                env.pop(wandb.env.SERVICE, None)
+                # Upon spawning the subprocess in a new process group, the child's process group is
+                # not connected to the controlling terminal's stdin. If it tries to access stdin,
+                # it gets a SIGTTIN and blocks until we give it the terminal, which we don't want
+                # to do.
+                #
+                # By using subprocess.PIPE, we give it an independent stdin. However, it will still
+                # block if it tries to read from stdin, because we're not writing anything to it.
+                # We immediately close the subprocess's stdin here so it can fail fast and get an
+                # EOF.
+                #
+                # (One situation that makes this relevant is that importing `readline` even
+                # indirectly can cause the child to attempt to access stdin, which can trigger the
+                # deadlock. In Python 3.13, `import torch` indirectly imports `readline` via `pdb`,
+                # meaning `import torch` in a run script can deadlock unless we override stdin.
+                # See https://github.com/wandb/wandb/pull/10489 description for more details.)
+                #
+                # Also, we avoid spawning a new session because that breaks preempted child process
+                # handling.
+                self._popen = subprocess.Popen(
+                    command,
+                    env=env,
+                    stdin=subprocess.PIPE,
+                    **kwargs,
+                )
+                self._popen.stdin.close()
         elif function:
             self._proc = multiprocessing.Process(
                 target=self._start,

{wandb-0.21.3.dist-info → wandb-0.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.21.3
+Version: 0.22.0
 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