wandb 0.20.2rc20250616__py3-none-win32.whl → 0.21.0__py3-none-win32.whl

wandb/sdk/lib/console_capture.py

@@ -25,17 +25,38 @@ In particular, it does not work with some combinations of pytest's
 
 from __future__ import annotations
 
+import logging
 import sys
 import threading
 from typing import IO, AnyStr, Callable, Protocol
 
+from . import wb_logging
+
+_logger = logging.getLogger(__name__)
+
 
 class CannotCaptureConsoleError(Exception):
     """The module failed to patch stdout or stderr."""
 
 
 class _WriteCallback(Protocol):
-    """A callback that receives intercepted bytes or string data."""
+    """A callback that receives intercepted bytes or string data.
+
+    This may be called from any thread, but is only called from one thread
+    at a time.
+
+    Note on errors: Any error raised during the callback will clear all
+    callbacks. This means that if a user presses Ctrl-C at an unlucky time
+    during a run, we will stop uploading console output---but it's not
+    likely to be a problem unless something catches the KeyboardInterrupt.
+
+    Regular Exceptions are caught and logged instead of bubbling up to the
+    user's print() statements; other exceptions like KeyboardInterrupt are
+    re-raised.
+
+    Callbacks should handle all exceptions---a callback that raises any
+    Exception is considered buggy.
+    """
 
     def __call__(
         self,
@@ -45,6 +66,8 @@ class _WriteCallback(Protocol):
     ) -> None:
         """Intercept data passed to `write()`.
 
+        See the protocol docstring for information about exceptions.
+
         Args:
             data: The object passed to stderr's or stdout's `write()`.
             written: The number of bytes or characters written.
@@ -52,7 +75,9 @@ class _WriteCallback(Protocol):
         """
 
 
-_module_lock = threading.Lock()
+# A reentrant lock is used to catch callbacks that write to stderr/stdout.
+_module_rlock = threading.RLock()
+_is_writing = False
 
 _patch_exception: CannotCaptureConsoleError | None = None
 
@@ -67,9 +92,6 @@ def capture_stdout(callback: _WriteCallback) -> Callable[[], None]:
 
     Args:
         callback: A callback to invoke after running `sys.stdout.write`.
-            This may be called from any thread, so it must be thread-safe.
-            Exceptions are propagated to the caller of `write`.
-            See `_WriteCallback` for the exact protocol.
 
     Returns:
         A function to uninstall the callback.
@@ -77,7 +99,7 @@ def capture_stdout(callback: _WriteCallback) -> Callable[[], None]:
     Raises:
         CannotCaptureConsoleError: If patching failed on import.
     """
-    with _module_lock:
+    with _module_rlock:
         if _patch_exception:
             raise _patch_exception
 
@@ -92,9 +114,6 @@ def capture_stderr(callback: _WriteCallback) -> Callable[[], None]:
 
     Args:
         callback: A callback to invoke after running `sys.stderr.write`.
-            This may be called from any thread, so it must be thread-safe.
-            Exceptions are propagated to the caller of `write`.
-            See `_WriteCallback` for the exact protocol.
 
     Returns:
         A function to uninstall the callback.
@@ -102,7 +121,7 @@ def capture_stderr(callback: _WriteCallback) -> Callable[[], None]:
     Raises:
         CannotCaptureConsoleError: If patching failed on import.
     """
-    with _module_lock:
+    with _module_rlock:
         if _patch_exception:
             raise _patch_exception
 
@@ -125,11 +144,11 @@ def _insert_disposably(
     def dispose() -> None:
         nonlocal disposed
 
-        with _module_lock:
+        with _module_rlock:
             if disposed:
                 return
 
-            del callback_dict[id]
+            callback_dict.pop(id, None)
 
             disposed = True
 
@@ -143,16 +162,44 @@ def _patch(
 ) -> None:
     orig_write: Callable[[AnyStr], int]
 
+    @wb_logging.log_to_all_runs()
     def write_with_callbacks(s: AnyStr, /) -> int:
+        global _is_writing
         n = orig_write(s)
 
-        # We make a copy here because callbacks could, in theory, modify
-        # the list of callbacks.
-        with _module_lock:
-            callbacks_copy = list(callbacks.values())
-
-        for cb in callbacks_copy:
-            cb(s, n)
+        # NOTE: Since _module_rlock is reentrant, this is safe. It will not
+        # deadlock if a callback invokes write() again.
+        with _module_rlock:
+            if _is_writing:
+                return n
+
+            _is_writing = True
+            try:
+                for cb in callbacks.values():
+                    cb(s, n)
+
+            except BaseException as e:
+                # Clear all callbacks on any exception to avoid infinite loops:
+                #
+                # * If we re-raise, an exception handler is likely to print
+                #   the exception to the console and trigger callbacks again
+                # * If we log, we can't guarantee that this doesn't print
+                #   to console.
+                #
+                # This is especially important for KeyboardInterrupt.
+                _stderr_callbacks.clear()
+                _stdout_callbacks.clear()
+
+                if isinstance(e, Exception):
+                    # We suppress Exceptions so that bugs in W&B code don't
+                    # cause the user's print() statements to raise errors.
+                    _logger.exception("Error in console callback, clearing all!")
+                else:
+                    # Re-raise errors like KeyboardInterrupt.
+                    raise
+
+            finally:
+                _is_writing = False
 
         return n
 

wandb/sdk/wandb_init.py

@@ -740,7 +740,6 @@ class _WandbInit:
         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()
 
         # methods
         drun.log = lambda data, *_, **__: drun.summary.update(data)  # type: ignore[method-assign]
@@ -1365,7 +1364,7 @@ def init(  # noqa: C901
             the UI.
             If resuming a run, the tags provided here will replace any existing
             tags. To add tags to a resumed run without overwriting the current
-            tags, use `run.tags += ["new_tag"]` after calling `run = wandb.init()`.
+            tags, use `run.tags += ("new_tag",)` after calling `run = wandb.init()`.
         config: Sets `wandb.config`, a dictionary-like object for storing input
             parameters to your run, such as model hyperparameters or data
             preprocessing settings.

wandb/sdk/wandb_require.py

@@ -60,7 +60,6 @@ class _Requires:
             func()
 
         if last_message:
-            wandb.termwarn("Supported requirements are: `legacy-service`, `service`.")
             raise UnsupportedError(last_message)
 
 

wandb/sdk/wandb_run.py

@@ -35,13 +35,13 @@ from wandb.integration.torch import wandb_torch
 from wandb.plot import CustomChart, Visualize
 from wandb.proto.wandb_deprecated import Deprecated
 from wandb.proto.wandb_internal_pb2 import (
-    MetadataRequest,
     MetricRecord,
     PollExitResponse,
     Result,
     RunRecord,
 )
 from wandb.sdk.artifacts._internal_artifact import InternalArtifact
+from wandb.sdk.artifacts._validators import is_artifact_registry_project
 from wandb.sdk.artifacts.artifact import Artifact
 from wandb.sdk.internal import job_builder
 from wandb.sdk.lib import asyncio_compat, wb_logging
@@ -63,7 +63,7 @@ from wandb.util import (
 from . import wandb_config, wandb_metric, wandb_summary
 from .artifacts._validators import (
     MAX_ARTIFACT_METADATA_KEYS,
-    is_artifact_registry_project,
+    ArtifactPath,
     validate_aliases,
     validate_tags,
 )
@@ -92,7 +92,6 @@ from .mailbox import (
     wait_with_progress,
 )
 from .wandb_alerts import AlertLevel
-from .wandb_metadata import Metadata
 from .wandb_settings import Settings
 from .wandb_setup import _WandbSetup
 
@@ -168,6 +167,7 @@ class RunStatusChecker:
         self,
         run_id: str,
         interface: InterfaceBase,
+        settings: Settings,
         stop_polling_interval: int = 15,
         retry_polling_interval: int = 5,
         internal_messages_polling_interval: int = 10,
@@ -177,6 +177,7 @@ class RunStatusChecker:
         self._stop_polling_interval = stop_polling_interval
         self._retry_polling_interval = retry_polling_interval
         self._internal_messages_polling_interval = internal_messages_polling_interval
+        self._settings = settings
 
         self._join_event = threading.Event()
 
@@ -318,9 +319,15 @@ class RunStatusChecker:
 
     def check_internal_messages(self) -> None:
         def _process_internal_messages(result: Result) -> None:
+            if (
+                not self._settings.show_warnings
+                or self._settings.quiet
+                or self._settings.silent
+            ):
+                return
             internal_messages = result.response.internal_messages_response
             for msg in internal_messages.messages.warning:
-                wandb.termwarn(msg)
+                wandb.termwarn(msg, repeat=False)
 
         with wb_logging.log_to_run(self._run_id):
             try:
@@ -620,8 +627,6 @@ class Run:
         )
         self.summary._set_update_callback(self._summary_update_callback)
 
-        self.__metadata: Metadata | None = None
-
         self._step = 0
         self._starting_step = 0
         self._start_runtime = 0
@@ -1647,7 +1652,7 @@ class Run:
     def _populate_git_info(self) -> None:
         from .lib.gitlib import GitRepo
 
-        # Use user provided git info if available otherwise resolve it from the environment
+        # Use user-provided git info if available, otherwise resolve it from the environment
         try:
             repo = GitRepo(
                 root=self._settings.git_root,
@@ -2481,6 +2486,7 @@ class Run:
             self._run_status_checker = RunStatusChecker(
                 self._settings.run_id,
                 interface=self._backend.interface,
+                settings=self._settings,
             )
             self._run_status_checker.start()
 
@@ -2947,13 +2953,6 @@ class Run:
             The linked artifact if linking was successful, otherwise None.
 
         """
-        portfolio, project, entity = wandb.util._parse_entity_project_item(target_path)
-        if aliases is None:
-            aliases = []
-
-        if not self._backend or not self._backend.interface:
-            return None
-
         if artifact.is_draft() and not artifact._is_draft_save_started():
             artifact = self._log_artifact(artifact)
 
@@ -2961,52 +2960,17 @@ class Run:
             # TODO: implement offline mode + sync
             raise NotImplementedError
 
-        # Wait until the artifact is committed before trying to link it.
-        artifact.wait()
-
-        organization = ""
-        if is_artifact_registry_project(project):
-            organization = entity or self.settings.organization or ""
-            # In a Registry linking, the entity is used to fetch the organization of the artifact
-            # therefore the source artifact's entity is passed to the backend
-            entity = artifact._source_entity
-        project = project or self.project
-        entity = entity or self.entity
-        handle = self._backend.interface.deliver_link_artifact(
-            artifact,
-            portfolio,
-            aliases,
-            entity,
-            project,
-            organization,
-        )
-        if artifact._ttl_duration_seconds is not None:
-            wandb.termwarn(
-                "Artifact TTL will be disabled for source artifacts that are linked to portfolios."
-            )
-        result = handle.wait_or(timeout=None)
-        response = result.response.link_artifact_response
-        if response.error_message:
-            wandb.termerror(response.error_message)
-            return None
-        if response.version_index is None:
-            wandb.termerror(
-                "Error fetching the linked artifact's version index after linking"
-            )
-            return None
+        # Normalize the target "entity/project/collection" with defaults
+        # inferred from this run's entity and project, if needed.
+        #
+        # HOWEVER, if the target path is a registry collection, avoid setting
+        # the target entity to the run's entity.  Instead, delegate to
+        # Artifact.link() to resolve the required org entity.
+        target = ArtifactPath.from_str(target_path)
+        if not (target.project and is_artifact_registry_project(target.project)):
+            target = target.with_defaults(prefix=self.entity, project=self.project)
 
-        try:
-            artifact_name = f"{entity}/{project}/{portfolio}:v{response.version_index}"
-            if is_artifact_registry_project(project):
-                if organization:
-                    artifact_name = f"{organization}/{project}/{portfolio}:v{response.version_index}"
-                else:
-                    artifact_name = f"{project}/{portfolio}:v{response.version_index}"
-            linked_artifact = self._public_api()._artifact(artifact_name)
-        except Exception as e:
-            wandb.termerror(f"Error fetching link artifact after linking: {e}")
-            return None
-        return linked_artifact
+        return artifact.link(target.to_str(), aliases)
 
     @_log_to_run
     @_raise_if_finished
@@ -3734,60 +3698,6 @@ class Run:
                 logger.exception("Error getting system metrics.")
                 return {}
 
-    @property
-    @_log_to_run
-    @_attach
-    @_raise_if_finished
-    def _metadata(self) -> Metadata | None:
-        """The metadata associated with this run.
-
-        NOTE: Automatically collected metadata can be overridden by the user.
-        """
-        if not self._backend or not self._backend.interface:
-            return self.__metadata
-
-        # Initialize the metadata object if it doesn't exist.
-        if self.__metadata is None:
-            self.__metadata = Metadata()
-            self.__metadata._set_callback(self._metadata_callback)
-
-        handle = self._backend.interface.deliver_get_system_metadata()
-
-        try:
-            result = handle.wait_or(timeout=1)
-        except TimeoutError:
-            logger.exception("Timeout getting run metadata.")
-            return None
-
-        response = result.response.get_system_metadata_response
-
-        # Temporarily disable the callback to prevent triggering
-        # an update call to wandb-core with the callback.
-        with self.__metadata.disable_callback():
-            # Values stored in the metadata object take precedence.
-            self.__metadata.update_from_proto(response.metadata, skip_existing=True)
-
-        return self.__metadata
-
-    @_log_to_run
-    @_raise_if_finished
-    @_attach
-    def _metadata_callback(
-        self,
-        metadata: MetadataRequest,
-    ) -> None:
-        """Callback to publish Metadata to wandb-core upon user updates."""
-        # ignore updates if the attached to another run
-        if self._is_attached:
-            wandb.termwarn(
-                "Metadata updates are ignored when attached to another run.",
-                repeat=False,
-            )
-            return
-
-        if self._backend and self._backend.interface:
-            self._backend.interface.publish_metadata(metadata)
-
     # ------------------------------------------------------------------------------
     # HEADER
     # ------------------------------------------------------------------------------