wandb 0.19.9__py3-none-win32.whl → 0.19.11__py3-none-win32.whl

wandb/sdk/wandb_run.py

@@ -14,13 +14,26 @@ import sys
 import threading
 import time
 import traceback
-import warnings
 from collections.abc import Mapping
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from enum import IntEnum
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, Literal, NamedTuple, Sequence, TextIO
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Literal,
+    NamedTuple,
+    Sequence,
+    TextIO,
+    TypeVar,
+)
+
+if sys.version_info < (3, 10):
+    from typing_extensions import Concatenate, ParamSpec
+else:
+    from typing import Concatenate, ParamSpec
 
 import requests
 
@@ -28,13 +41,13 @@ import wandb
 import wandb.env
 import wandb.util
 from wandb import trigger
-from wandb._globals import _datatypes_set_callback
 from wandb.apis import internal, public
 from wandb.apis.public import Api as PublicApi
 from wandb.errors import CommError, UnsupportedError, UsageError
 from wandb.errors.links import url_registry
 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,
@@ -361,7 +374,13 @@ class RunStatusChecker:
         self._internal_messages_thread.join()
 
 
-def _log_to_run(func: Callable) -> Callable:
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+
+
+def _log_to_run(
+    func: Callable[Concatenate[Run, _P], _T],
+) -> Callable[Concatenate[Run, _P], _T]:
     """Decorate a Run method to set the run ID in the logging context.
 
     Any logs during the execution of the method go to the run's log file
@@ -375,7 +394,7 @@ def _log_to_run(func: Callable) -> Callable:
     """
 
     @functools.wraps(func)
-    def wrapper(self: Run, *args, **kwargs) -> Any:
+    def wrapper(self: Run, *args, **kwargs) -> _T:
         # In "attach" usage, many properties of the Run are not initially
         # populated.
         if hasattr(self, "_settings"):
@@ -389,100 +408,118 @@ def _log_to_run(func: Callable) -> Callable:
     return wrapper
 
 
-class _run_decorator:  # noqa: N801
-    _is_attaching: str = ""
-
-    class Dummy: ...
-
-    @classmethod
-    def _attach(cls, func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(self: type[Run], *args: Any, **kwargs: Any) -> Any:
-            # * `_attach_id` is only assigned in service hence for all non-service cases
-            # it will be a passthrough.
-            # * `_attach_pid` is only assigned in _init (using _attach_pid guarantees single attach):
-            #   - for non-fork case the object is shared through pickling so will be None.
-            #   - for fork case the new process share mem space hence the value would be of parent process.
-            if (
-                getattr(self, "_attach_id", None)
-                and getattr(self, "_attach_pid", None) != os.getpid()
-            ):
-                if cls._is_attaching:
-                    message = (
-                        f"Trying to attach `{func.__name__}` "
-                        f"while in the middle of attaching `{cls._is_attaching}`"
-                    )
-                    raise RuntimeError(message)
-                cls._is_attaching = func.__name__
-                try:
-                    wandb._attach(run=self)  # type: ignore
-                except Exception as e:
-                    # In case the attach fails we will raise the exception that caused the issue.
-                    # This exception should be caught and fail the execution of the program.
-                    cls._is_attaching = ""
-                    raise e
-                cls._is_attaching = ""
-            return func(self, *args, **kwargs)
+_is_attaching: str = ""
+
 
-        return wrapper
+def _attach(
+    func: Callable[Concatenate[Run, _P], _T],
+) -> Callable[Concatenate[Run, _P], _T]:
+    """Decorate a Run method to auto-attach when in a new process.
 
-    @classmethod
-    def _noop_on_finish(cls, message: str = "", only_warn: bool = False) -> Callable:
-        def decorator_fn(func: Callable) -> Callable:
-            @functools.wraps(func)
-            def wrapper_fn(self: type[Run], *args: Any, **kwargs: Any) -> Any:
-                if not getattr(self, "_is_finished", False):
-                    return func(self, *args, **kwargs)
+    When in a forked process or using a pickled Run instance, this automatically
+    connects to the service process to "attach" to the existing run.
+    """
+
+    @functools.wraps(func)
+    def wrapper(self: Run, *args, **kwargs) -> _T:
+        global _is_attaching
 
-                default_message = (
-                    f"Run ({self.id}) is finished. The call to `{func.__name__}` will be ignored. "
-                    f"Please make sure that you are using an active run."
+        # The _attach_id attribute is only None when running in the "disable
+        # service" mode.
+        #
+        # Since it is set early in `__init__` and included in the run's pickled
+        # state, the attribute always exists.
+        is_using_service = self._attach_id is not None
+
+        # The _attach_pid attribute is not pickled, so it might not exist.
+        # It is set when the run is initialized.
+        attach_pid = getattr(self, "_attach_pid", None)
+
+        if is_using_service and attach_pid != os.getpid():
+            if _is_attaching:
+                raise RuntimeError(
+                    f"Trying to attach `{func.__name__}`"
+                    f" while in the middle of attaching `{_is_attaching}`"
                 )
-                resolved_message = message or default_message
-                if only_warn:
-                    warnings.warn(resolved_message, UserWarning, stacklevel=2)
-                else:
-                    raise UsageError(resolved_message)
-
-            return wrapper_fn
-
-        return decorator_fn
-
-    @classmethod
-    def _noop(cls, func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(self: type[Run], *args: Any, **kwargs: Any) -> Any:
-            # `_attach_id` is only assigned in service hence for all service cases
-            # it will be a passthrough. We don't pickle non-service so again a way
-            # to see that we are in non-service case
-            if getattr(self, "_attach_id", None) is None:
-                # `_init_pid` is only assigned in __init__ (this will be constant check for mp):
-                #   - for non-fork case the object is shared through pickling,
-                #     and we don't pickle non-service so will be None
-                #   - for fork case the new process share mem space hence the value would be of parent process.
-                _init_pid = getattr(self, "_init_pid", None)
-                if _init_pid != os.getpid():
-                    message = (
-                        f"`{func.__name__}` ignored (called from pid={os.getpid()}, "
-                        f"`init` called from pid={_init_pid}). "
-                        f"See: {url_registry.url('multiprocess')}"
-                    )
-                    # - if this process was pickled in non-service case,
-                    #   we ignore the attributes (since pickle is not supported)
-                    # - for fork case will use the settings of the parent process
-                    # - only point of inconsistent behavior from forked and non-forked cases
-                    settings = getattr(self, "_settings", None)
-                    if settings and settings.strict:
-                        wandb.termerror(message, repeat=False)
-                        raise UnsupportedError(
-                            f"`{func.__name__}` does not support multiprocessing"
-                        )
-                    wandb.termwarn(message, repeat=False)
-                    return cls.Dummy()
 
+            _is_attaching = func.__name__
+            try:
+                wandb._attach(run=self)  # type: ignore
+            finally:
+                _is_attaching = ""
+
+        return func(self, *args, **kwargs)
+
+    return wrapper
+
+
+def _raise_if_finished(
+    func: Callable[Concatenate[Run, _P], _T],
+) -> Callable[Concatenate[Run, _P], _T]:
+    """Decorate a Run method to raise an error after the run is finished."""
+
+    @functools.wraps(func)
+    def wrapper_fn(self: Run, *args, **kwargs) -> _T:
+        if not getattr(self, "_is_finished", False):
+            return func(self, *args, **kwargs)
+
+        message = (
+            f"Run ({self.id}) is finished. The call to"
+            f" `{func.__name__}` will be ignored."
+            f" Please make sure that you are using an active run."
+        )
+
+        raise UsageError(message)
+
+    return wrapper_fn
+
+
+def _noop_if_forked_with_no_service(
+    func: Callable[Concatenate[Run, _P], None],
+) -> Callable[Concatenate[Run, _P], None]:
+    """Do nothing if called in a forked process and service is disabled.
+
+    Disabling the service is a very old and barely supported setting.
+    """
+
+    @functools.wraps(func)
+    def wrapper(self: Run, *args, **kwargs) -> None:
+        # The _attach_id attribute is only None when running in the "disable
+        # service" mode.
+        #
+        # Since it is set early in `__init__` and included in the run's pickled
+        # state, the attribute always exists.
+        is_using_service = self._attach_id is not None
+
+        # This is the PID in which the Run object was constructed. The attribute
+        # always exists because it is set early in `__init__` and is included
+        # in the pickled state in `__getstate__` and `__setstate__`.
+        #
+        # It is not equal to the current PID if the process was forked or if
+        # the Run object was pickled and sent to another process.
+        init_pid = self._init_pid
+
+        if is_using_service or init_pid == os.getpid():
             return func(self, *args, **kwargs)
 
-        return wrapper
+        message = (
+            f"`{func.__name__}` ignored (called from pid={os.getpid()},"
+            f" `init` called from pid={init_pid})."
+            f" See: {url_registry.url('multiprocess')}"
+        )
+
+        # This attribute may not exist because it is not included in the run's
+        # pickled state.
+        settings = getattr(self, "_settings", None)
+        if settings and settings.strict:
+            wandb.termerror(message, repeat=False)
+            raise UnsupportedError(
+                f"`{func.__name__}` does not support multiprocessing"
+            )
+        wandb.termwarn(message, repeat=False)
+        return None
+
+    return wrapper
 
 
 @dataclass
@@ -606,6 +643,7 @@ class Run:
     ) -> None:
         # pid is set, so we know if this run object was initialized by this process
         self._init_pid = os.getpid()
+        self._attach_id = None
 
         if settings._noop:
             # TODO: properly handle setting for disabled mode
@@ -647,14 +685,13 @@ class Run:
 
         self._step = 0
         self._starting_step = 0
+        self._start_runtime = 0
         # TODO: eventually would be nice to make this configurable using self._settings._start_time
         #  need to test (jhr): if you set start time to 2 days ago and run a test for 15 minutes,
         #  does the total time get calculated right (not as 2 days and 15 minutes)?
         self._start_time = time.time()
 
-        _datatypes_set_callback(self._datatypes_callback)
-
-        self._printer = printer.new_printer()
+        self._printer = printer.new_printer(settings)
 
         self._torch_history: wandb_torch.TorchHistory | None = None  # type: ignore
 
@@ -776,8 +813,9 @@ class Run:
                     self._unique_launch_artifact_sequence_names[sequence_name] = item
 
     def _telemetry_callback(self, telem_obj: telemetry.TelemetryRecord) -> None:
-        if not hasattr(self, "_telemetry_obj"):
+        if not hasattr(self, "_telemetry_obj") or self._is_finished:
             return
+
         self._telemetry_obj.MergeFrom(telem_obj)
         self._telemetry_obj_dirty = True
         self._telemetry_flush()
@@ -846,47 +884,45 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def settings(self) -> Settings:
         """A frozen copy of run's Settings object."""
         return self._settings.model_copy(deep=True)
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def dir(self) -> str:
         """The directory where files associated with the run are saved."""
         return self._settings.files_dir
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def config(self) -> wandb_config.Config:
         """Config object associated with this run."""
         return self._config
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def config_static(self) -> wandb_config.ConfigStatic:
         return wandb_config.ConfigStatic(self._config)
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def name(self) -> str | None:
         """Display name of the run.
 
         Display names are not guaranteed to be unique and may be descriptive.
         By default, they are randomly generated.
         """
-        if self._settings.run_name:
-            return self._settings.run_name
-        return None
+        return self._settings.run_name
 
     @name.setter
     @_log_to_run
-    @_run_decorator._noop_on_finish()
+    @_raise_if_finished
     def name(self, name: str) -> None:
         with telemetry.context(run=self) as tel:
             tel.feature.set_run_name = True
@@ -896,18 +932,18 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def notes(self) -> str | None:
         """Notes associated with the run, if there are any.
 
-        Notes can be a multiline string and can also use markdown and latex equations
-        inside `$$`, like `$x + 3$`.
+        Notes can be a multiline string and can also use markdown and latex
+        equations inside `$$`, like `$x + 3$`.
         """
         return self._settings.run_notes
 
     @notes.setter
     @_log_to_run
-    @_run_decorator._noop_on_finish()
+    @_raise_if_finished
     def notes(self, notes: str) -> None:
         self._settings.run_notes = notes
         if self._backend and self._backend.interface:
@@ -915,14 +951,14 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def tags(self) -> tuple | None:
         """Tags associated with the run, if there are any."""
         return self._settings.run_tags or ()
 
     @tags.setter
     @_log_to_run
-    @_run_decorator._noop_on_finish()
+    @_raise_if_finished
     def tags(self, tags: Sequence) -> None:
         with telemetry.context(run=self) as tel:
             tel.feature.set_run_tags = True
@@ -932,18 +968,17 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def id(self) -> str:
         """Identifier for this run."""
-        if TYPE_CHECKING:
-            assert self._settings.run_id is not None
+        assert self._settings.run_id is not None
         return self._settings.run_id
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def sweep_id(self) -> str | None:
-        """ID of the sweep associated with the run, if there is one."""
+        """Identifier for the sweep associated with the run, if there is one."""
         return self._settings.sweep_id
 
     def _get_path(self) -> str:
@@ -959,7 +994,7 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def path(self) -> str:
         """Path to the run.
 
@@ -970,28 +1005,28 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def start_time(self) -> float:
         """Unix timestamp (in seconds) of when the run started."""
         return self._start_time
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def starting_step(self) -> int:
         """The first step of the run."""
         return self._starting_step
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def resumed(self) -> bool:
         """True if the run was resumed, False otherwise."""
         return self._settings.resumed
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def step(self) -> int:
         """Current value of the step.
 
@@ -1001,34 +1036,34 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def mode(self) -> str:
         """For compatibility with `0.9.x` and earlier, deprecate eventually."""
-        if hasattr(self, "_telemetry_obj"):
-            deprecate.deprecate(
-                field_name=deprecate.Deprecated.run__mode,
-                warning_message=(
-                    "The mode property of wandb.run is deprecated "
-                    "and will be removed in a future release."
-                ),
-            )
+        deprecate.deprecate(
+            field_name=Deprecated.run__mode,
+            warning_message=(
+                "The mode property of wandb.run is deprecated "
+                "and will be removed in a future release."
+            ),
+            run=self,
+        )
         return "dryrun" if self._settings._offline else "run"
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def offline(self) -> bool:
         return self._settings._offline
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def disabled(self) -> bool:
         return self._settings._noop
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def group(self) -> str:
         """Name of the group associated with the run.
 
@@ -1043,24 +1078,67 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def job_type(self) -> str:
         return self._settings.run_job_type or ""
 
     def project_name(self) -> str:
-        # TODO: deprecate this in favor of project
-        return self._settings.project or ""
+        """Name of the W&B project associated with the run.
+
+        Note: this method is deprecated and will be removed in a future release.
+        Please use `run.project` instead.
+        """
+        deprecate.deprecate(
+            field_name=Deprecated.run__project_name,
+            warning_message=(
+                "The project_name method is deprecated and will be removed in a"
+                " future release. Please use `run.project` instead."
+            ),
+        )
+        return self.project
 
     @property
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def project(self) -> str:
         """Name of the W&B project associated with the run."""
-        return self.project_name()
+        assert self._settings.project is not None
+        return self._settings.project
 
-    @_run_decorator._noop_on_finish()
     @_log_to_run
-    @_run_decorator._attach
+    def get_project_url(self) -> str | None:
+        """URL of the W&B project associated with the run, if there is one.
+
+        Offline runs do not have a project URL.
+
+        Note: this method is deprecated and will be removed in a future release.
+        Please use `run.project_url` instead.
+        """
+        deprecate.deprecate(
+            field_name=Deprecated.run__get_project_url,
+            warning_message=(
+                "The get_project_url method is deprecated and will be removed in a"
+                " future release. Please use `run.project_url` instead."
+            ),
+        )
+        return self.project_url
+
+    @property
+    @_log_to_run
+    @_attach
+    def project_url(self) -> str | None:
+        """URL of the W&B project associated with the run, if there is one.
+
+        Offline runs do not have a project URL.
+        """
+        if self._settings._offline:
+            wandb.termwarn("URL not available in offline run")
+            return None
+        return self._settings.project_url
+
+    @_raise_if_finished
+    @_log_to_run
+    @_attach
     def log_code(
         self,
         root: str | None = ".",
@@ -1144,22 +1222,40 @@ class Run:
             )
             return None
 
-        return self._log_artifact(art)
+        artifact = self._log_artifact(art)
 
-    @_log_to_run
-    def get_project_url(self) -> str | None:
-        """Return the url for the W&B project associated with the run, if there is one.
+        self._config.update(
+            {"_wandb": {"code_path": artifact.name}},
+            allow_val_change=True,
+        )
 
-        Offline runs will not have a project url.
-        """
-        if self._settings._offline:
-            wandb.termwarn("URL not available in offline run")
-            return None
-        return self._settings.project_url
+        return artifact
 
     @_log_to_run
     def get_sweep_url(self) -> str | None:
-        """Return the url for the sweep associated with the run, if there is one."""
+        """The URL of the sweep associated with the run, if there is one.
+
+        Offline runs do not have a sweep URL.
+
+        Note: this method is deprecated and will be removed in a future release.
+        Please use `run.sweep_url` instead.
+        """
+        deprecate.deprecate(
+            field_name=Deprecated.run__get_sweep_url,
+            warning_message=(
+                "The get_sweep_url method is deprecated and will be removed in a"
+                " future release. Please use `run.sweep_url` instead."
+            ),
+        )
+        return self.sweep_url
+
+    @property
+    @_attach
+    def sweep_url(self) -> str | None:
+        """URL of the sweep associated with the run, if there is one.
+
+        Offline runs do not have a sweep URL.
+        """
         if self._settings._offline:
             wandb.termwarn("URL not available in offline run")
             return None
@@ -1167,7 +1263,27 @@ class Run:
 
     @_log_to_run
     def get_url(self) -> str | None:
-        """Return the url for the W&B run, if there is one.
+        """URL of the W&B run, if there is one.
+
+        Offline runs do not have a URL.
+
+        Note: this method is deprecated and will be removed in a future release.
+        Please use `run.url` instead.
+        """
+        deprecate.deprecate(
+            field_name=Deprecated.run__get_url,
+            warning_message=(
+                "The get_url method is deprecated and will be removed in a"
+                " future release. Please use `run.url` instead."
+            ),
+        )
+        return self.url
+
+    @property
+    @_log_to_run
+    @_attach
+    def url(self) -> str | None:
+        """The url for the W&B run, if there is one.
 
         Offline runs will not have a url.
         """
@@ -1178,14 +1294,7 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
-    def url(self) -> str | None:
-        """The W&B url associated with the run."""
-        return self.get_url()
-
-    @property
-    @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def entity(self) -> str:
         """The name of the W&B entity associated with the run.
 
@@ -1280,7 +1389,7 @@ class Run:
             self._label_probe_lines(lines)
 
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def display(self, height: int = 420, hidden: bool = False) -> bool:
         """Display this run in jupyter."""
         if self._settings.silent:
@@ -1300,7 +1409,7 @@ class Run:
             return False
 
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def to_html(self, height: int = 420, hidden: bool = False) -> str:
         """Generate HTML containing an iframe displaying the current run."""
         url = self._settings.run_url + "?jupyter=true"
@@ -1317,7 +1426,7 @@ class Run:
         return {"text/html": self.to_html(hidden=True)}
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
+    @_raise_if_finished
     def _config_callback(
         self,
         key: tuple[str, ...] | str | None = None,
@@ -1339,6 +1448,8 @@ class Run:
             assert isinstance(val, dict)
             public_api = self._public_api()
             artifact = Artifact._from_id(val["id"], public_api.client)
+
+            assert artifact
             return self.use_artifact(artifact, use_as=key)
         elif _is_artifact_string(val):
             # this will never fail, but is required to make mypy happy
@@ -1357,6 +1468,7 @@ class Run:
             # in the future we'll need to support using artifacts from
             # different instances of wandb.
 
+            assert artifact
             return self.use_artifact(artifact, use_as=key)
         elif _is_artifact_object(val):
             return self.use_artifact(val, use_as=key)
@@ -1369,7 +1481,7 @@ class Run:
         self._config_callback(key=("_wandb", key), val=val)
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
+    @_raise_if_finished
     def _summary_update_callback(self, summary_record: SummaryRecord) -> None:
         with telemetry.context(run=self) as tel:
             tel.feature.set_summary = True
@@ -1400,7 +1512,16 @@ class Run:
             self._backend.interface._publish_metric(metric_record)
 
     @_log_to_run
-    def _datatypes_callback(self, fname: str) -> None:
+    def _publish_file(self, fname: str) -> None:
+        """Mark a run file to be uploaded with the run.
+
+        This is a W&B-internal function: it can be used by other internal
+        wandb code.
+
+        Args:
+            fname: The path to the file in the run's files directory, relative
+                to the run's files directory.
+        """
         if not self._backend or not self._backend.interface:
             return
         files: FilesDict = dict(files=[(GlobStr(fname), "now")])
@@ -1502,7 +1623,7 @@ class Run:
             self._backend.interface.publish_output(name, data)
 
     @_log_to_run
-    @_run_decorator._noop_on_finish(only_warn=True)
+    @_raise_if_finished
     def _console_raw_callback(self, name: str, data: str) -> None:
         # logger.info("console callback: %s, %s", name, data)
 
@@ -1548,6 +1669,9 @@ class Run:
         if run_obj.start_time:
             self._start_time = run_obj.start_time.ToMicroseconds() / 1e6
 
+        if run_obj.runtime:
+            self._start_runtime = run_obj.runtime
+
         # Grab the config from resuming
         if run_obj.config:
             c_dict = config_util.dict_no_value_from_proto_list(run_obj.config.update)
@@ -1683,9 +1807,9 @@ class Run:
             self._step += 1
 
     @_log_to_run
-    @_run_decorator._noop
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_noop_if_forked_with_no_service
+    @_raise_if_finished
+    @_attach
     def log(
         self,
         data: dict[str, Any],
@@ -1931,10 +2055,11 @@ class Run:
 
         if sync is not None:
             deprecate.deprecate(
-                field_name=deprecate.Deprecated.run__log_sync,
+                field_name=Deprecated.run__log_sync,
                 warning_message=(
                     "`sync` argument is deprecated and does not affect the behaviour of `wandb.log`"
                 ),
+                run=self,
             )
         if self._settings._shared and step is not None:
             wandb.termwarn(
@@ -1946,8 +2071,8 @@ class Run:
         self._log(data=data, step=step, commit=commit)
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def save(
         self,
         glob_str: str | os.PathLike | None = None,
@@ -2004,11 +2129,12 @@ class Run:
         if glob_str is None:
             # noop for historical reasons, run.save() may be called in legacy code
             deprecate.deprecate(
-                field_name=deprecate.Deprecated.run__save_no_args,
+                field_name=Deprecated.run__save_no_args,
                 warning_message=(
                     "Calling wandb.run.save without any arguments is deprecated."
                     "Changes to attributes are automatically persisted."
                 ),
+                run=self,
             )
             return True
 
@@ -2132,7 +2258,7 @@ class Run:
         return [str(f) for f in globbed_files]
 
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def restore(
         self,
         name: str,
@@ -2148,8 +2274,8 @@ class Run:
         )
 
     @_log_to_run
-    @_run_decorator._noop
-    @_run_decorator._attach
+    @_noop_if_forked_with_no_service
+    @_attach
     def finish(
         self,
         exit_code: int | None = None,
@@ -2173,11 +2299,12 @@ class Run:
         """
         if quiet is not None:
             deprecate.deprecate(
-                field_name=deprecate.Deprecated.run__finish_quiet,
+                field_name=Deprecated.run__finish_quiet,
                 warning_message=(
                     "The `quiet` argument to `wandb.run.finish()` is deprecated, "
                     "use `wandb.Settings(quiet=...)` to set this instead."
                 ),
+                run=self,
             )
         return self._finish(exit_code)
 
@@ -2186,6 +2313,11 @@ class Run:
         self,
         exit_code: int | None = None,
     ) -> None:
+        if self._is_finished:
+            return
+
+        assert self._wl
+
         logger.info(f"finishing run {self._get_path()}")
         with telemetry.context(run=self) as tel:
             tel.feature.finish = True
@@ -2199,6 +2331,7 @@ class Run:
         # Early-stage hooks may use methods that require _is_finished
         # to be False, so we set this after running those hooks.
         self._is_finished = True
+        self._wl.remove_active_run(self)
 
         try:
             self._atexit_cleanup(exit_code=exit_code)
@@ -2214,31 +2347,32 @@ class Run:
             #
             # TODO: Why not do this in _atexit_cleanup()?
             if self._settings.run_id:
-                assert self._wl
                 service = self._wl.assert_service()
                 service.inform_finish(run_id=self._settings.run_id)
 
         finally:
-            module.unset_globals()
+            if wandb.run is self:
+                module.unset_globals()
             wandb._sentry.end_session()
 
     @_log_to_run
-    @_run_decorator._noop
-    @_run_decorator._attach
+    @_noop_if_forked_with_no_service
+    @_attach
     def join(self, exit_code: int | None = None) -> None:
         """Deprecated alias for `finish()` - use finish instead."""
         if hasattr(self, "_telemetry_obj"):
             deprecate.deprecate(
-                field_name=deprecate.Deprecated.run__join,
+                field_name=Deprecated.run__join,
                 warning_message=(
                     "wandb.run.join() is deprecated, please use wandb.run.finish()."
                 ),
+                run=self,
             )
         self._finish(exit_code=exit_code)
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def status(
         self,
     ) -> RunStatus:
@@ -2270,25 +2404,6 @@ class Run:
         }
         self._config_callback(val=config, key=("_wandb", "visualize", visualize_key))
 
-    def _set_globals(self) -> None:
-        module.set_global(
-            run=self,
-            config=self.config,
-            log=self.log,
-            summary=self.summary,
-            save=self.save,
-            use_artifact=self.use_artifact,
-            log_artifact=self.log_artifact,
-            define_metric=self.define_metric,
-            alert=self.alert,
-            watch=self.watch,
-            unwatch=self.unwatch,
-            mark_preempting=self.mark_preempting,
-            log_model=self.log_model,
-            use_model=self.use_model,
-            link_model=self.link_model,
-        )
-
     def _redirect(
         self,
         stdout_slave_fd: int | None,
@@ -2327,6 +2442,7 @@ class Run:
                     lambda data: self._console_callback("stdout", data),
                     self._output_writer.write,  # type: ignore
                 ],
+                flush_periodically=(self._settings.mode == "online"),
             )
             err_redir = redirect.Redirect(
                 src="stderr",
@@ -2334,6 +2450,7 @@ class Run:
                     lambda data: self._console_callback("stderr", data),
                     self._output_writer.write,  # type: ignore
                 ],
+                flush_periodically=(self._settings.mode == "online"),
             )
             if os.name == "nt":
 
@@ -2359,6 +2476,7 @@ class Run:
                     lambda data: self._console_callback("stdout", data),
                     self._output_writer.write,  # type: ignore
                 ],
+                flush_periodically=(self._settings.mode == "online"),
             )
             err_redir = redirect.StreamWrapper(
                 src="stderr",
@@ -2366,6 +2484,7 @@ class Run:
                     lambda data: self._console_callback("stderr", data),
                     self._output_writer.write,  # type: ignore
                 ],
+                flush_periodically=(self._settings.mode == "online"),
             )
         elif console == "wrap_raw":
             logger.info("Wrapping output streams.")
@@ -2468,13 +2587,7 @@ class Run:
             self._output_writer = None
 
     def _on_start(self) -> None:
-        # would like to move _set_global to _on_ready to unify _on_start and _on_attach
-        # (we want to do the set globals after attach)
-        # TODO(console) However _console_start calls Redirect that uses `wandb.run` hence breaks
-        # TODO(jupyter) However _header calls _header_run_info that uses wandb.jupyter that uses
-        #               `wandb.run` and hence breaks
-        self._set_globals()
-        self._header(settings=self._settings, printer=self._printer)
+        self._header()
 
         if self._settings.save_code and self._settings.code_dir is not None:
             self.log_code(self._settings.code_dir)
@@ -2504,7 +2617,6 @@ class Run:
         with telemetry.context(run=self) as tel:
             tel.feature.attach = True
 
-        self._set_globals()
         self._is_attached = True
         self._on_ready()
 
@@ -2536,6 +2648,9 @@ class Run:
 
     def _on_ready(self) -> None:
         """Event triggered when run is ready for the user."""
+        assert self._wl
+        self._wl.add_active_run(self)
+
         self._register_telemetry_import_hooks()
 
         # start reporting any telemetry changes
@@ -2627,6 +2742,7 @@ class Run:
             docker_image_name=docker_image_name,
         )
 
+        assert job_artifact
         artifact = self.log_artifact(job_artifact)
 
         if not artifact:
@@ -2739,8 +2855,8 @@ class Run:
             unregister_post_import_hook(module_name, run_id)
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def define_metric(
         self,
         name: str,
@@ -2779,14 +2895,14 @@ class Run:
         """
         if summary and "copy" in summary:
             deprecate.deprecate(
-                deprecate.Deprecated.run__define_metric_copy,
+                Deprecated.run__define_metric_copy,
                 "define_metric(summary='copy') is deprecated and will be removed.",
                 self,
             )
 
         if (summary and "best" in summary) or goal is not None:
             deprecate.deprecate(
-                deprecate.Deprecated.run__define_metric_best_goal,
+                Deprecated.run__define_metric_best_goal,
                 "define_metric(summary='best', goal=...) is deprecated and will be removed. "
                 "Use define_metric(summary='min') or define_metric(summary='max') instead.",
                 self,
@@ -2881,7 +2997,7 @@ class Run:
         return m
 
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def watch(
         self,
         models: torch.nn.Module | Sequence[torch.nn.Module],
@@ -2919,7 +3035,7 @@ class Run:
         wandb.sdk._watch(self, models, criterion, log, log_freq, idx, log_graph)
 
     @_log_to_run
-    @_run_decorator._attach
+    @_attach
     def unwatch(
         self, models: torch.nn.Module | Sequence[torch.nn.Module] | None = None
     ) -> None:
@@ -2970,14 +3086,14 @@ class Run:
         pass
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def link_artifact(
         self,
         artifact: Artifact,
         target_path: str,
         aliases: list[str] | None = None,
-    ) -> None:
+    ) -> Artifact | None:
         """Link the given artifact to a portfolio (a promoted collection of artifacts).
 
         The linked artifact will be visible in the UI for the specified portfolio.
@@ -2991,7 +3107,7 @@ class Run:
             The alias "latest" will always be applied to the latest version of an artifact that is linked.
 
         Returns:
-            None
+            The linked artifact if linking was successful, otherwise None.
 
         """
         portfolio, project, entity = wandb.util._parse_entity_project_item(target_path)
@@ -2999,7 +3115,7 @@ class Run:
             aliases = []
 
         if not self._backend or not self._backend.interface:
-            return
+            return None
 
         if artifact.is_draft() and not artifact._is_draft_save_started():
             artifact = self._log_artifact(artifact)
@@ -3013,12 +3129,13 @@ class Run:
 
         organization = ""
         if is_artifact_registry_project(project):
-            organization = entity
+            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(
-            self,
             artifact,
             portfolio,
             aliases,
@@ -3034,10 +3151,28 @@ class Run:
         response = result.response.link_artifact_response
         if response.error_message:
             wandb.termerror(response.error_message)
+        if response.version_index is None:
+            wandb.termerror(
+                "Error fetching the linked artifact's version index after linking"
+            )
+            return None
+
+        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
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def use_artifact(
         self,
         artifact_or_name: str | Artifact,
@@ -3156,8 +3291,8 @@ class Run:
         return artifact
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def log_artifact(
         self,
         artifact_or_path: Artifact | StrPath,
@@ -3199,8 +3334,8 @@ class Run:
         )
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def upsert_artifact(
         self,
         artifact_or_path: Artifact | str,
@@ -3254,8 +3389,8 @@ class Run:
         )
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def finish_artifact(
         self,
         artifact_or_path: Artifact | str,
@@ -3456,8 +3591,8 @@ class Run:
         return artifact, _resolve_aliases(aliases)
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def log_model(
         self,
         path: StrPath,
@@ -3508,8 +3643,8 @@ class Run:
         )
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def use_model(self, name: str) -> FilePathStr:
         """Download the files logged in a model artifact 'name'.
 
@@ -3549,6 +3684,10 @@ class Run:
         Returns:
             path: (str) path to downloaded model artifact file(s).
         """
+        if self._settings._offline:
+            # Downloading artifacts is not supported when offline.
+            raise RuntimeError("`use_model` not supported in offline mode.")
+
         artifact = self.use_artifact(artifact_or_name=name)
         if "model" not in str(artifact.type.lower()):
             raise AssertionError(
@@ -3566,15 +3705,15 @@ class Run:
         return path
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def link_model(
         self,
         path: StrPath,
         registered_model_name: str,
         name: str | None = None,
         aliases: list[str] | None = None,
-    ) -> None:
+    ) -> Artifact | None:
         """Log a model artifact version and link it to a registered model in the model registry.
 
         The linked model version will be visible in the UI for the specified registered model.
@@ -3636,7 +3775,7 @@ class Run:
             ValueError: if name has invalid special characters
 
         Returns:
-            None
+            The linked artifact if linking was successful, otherwise None.
         """
         name_parts = registered_model_name.split("/")
         if len(name_parts) != 1:
@@ -3665,11 +3804,13 @@ class Run:
             artifact = self._log_artifact(
                 artifact_or_path=path, name=name, type="model"
             )
-        self.link_artifact(artifact=artifact, target_path=target_path, aliases=aliases)
+        return self.link_artifact(
+            artifact=artifact, target_path=target_path, aliases=aliases
+        )
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def alert(
         self,
         title: str,
@@ -3720,8 +3861,8 @@ class Run:
         return not exception_raised
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def mark_preempting(self) -> None:
         """Mark this run as preempting.
 
@@ -3732,8 +3873,8 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def _system_metrics(self) -> dict[str, list[tuple[datetime, float]]]:
         """Returns a dictionary of system metrics.
 
@@ -3781,8 +3922,8 @@ class Run:
 
     @property
     @_log_to_run
-    @_run_decorator._attach
-    @_run_decorator._noop_on_finish()
+    @_attach
+    @_raise_if_finished
     def _metadata(self) -> Metadata | None:
         """The metadata associated with this run.
 
@@ -3820,8 +3961,8 @@ class Run:
         return None
 
     @_log_to_run
-    @_run_decorator._noop_on_finish()
-    @_run_decorator._attach
+    @_raise_if_finished
+    @_attach
     def _metadata_callback(
         self,
         metadata: MetadataRequest,
@@ -3841,59 +3982,41 @@ class Run:
     # ------------------------------------------------------------------------------
     # HEADER
     # ------------------------------------------------------------------------------
-    # Note: All the header methods are static methods since we want to share the printing logic
-    # with the service execution path that doesn't have access to the run instance
-    @staticmethod
-    def _header(
-        *,
-        settings: Settings,
-        printer: printer.Printer,
-    ) -> None:
-        Run._header_wandb_version_info(settings=settings, printer=printer)
-        Run._header_sync_info(settings=settings, printer=printer)
-        Run._header_run_info(settings=settings, printer=printer)
+    def _header(self) -> None:
+        self._header_wandb_version_info()
+        self._header_sync_info()
+        self._header_run_info()
 
-    @staticmethod
-    def _header_wandb_version_info(
-        *,
-        settings: Settings,
-        printer: printer.Printer,
-    ) -> None:
-        if settings.quiet or settings.silent:
+    def _header_wandb_version_info(self) -> None:
+        if self._settings.quiet or self._settings.silent:
             return
 
         # TODO: add this to a higher verbosity level
-        printer.display(f"Tracking run with wandb version {wandb.__version__}")
+        self._printer.display(f"Tracking run with wandb version {wandb.__version__}")
 
-    @staticmethod
-    def _header_sync_info(
-        *,
-        settings: Settings,
-        printer: printer.Printer,
-    ) -> None:
-        if settings._offline:
-            printer.display(
+    def _header_sync_info(self) -> None:
+        if self._settings._offline:
+            self._printer.display(
                 [
-                    f"W&B syncing is set to {printer.code('`offline`')} in this directory.  ",
-                    f"Run {printer.code('`wandb online`')} or set {printer.code('WANDB_MODE=online')} "
-                    "to enable cloud syncing.",
+                    f"W&B syncing is set to {self._printer.code('`offline`')}"
+                    f" in this directory. Run {self._printer.code('`wandb online`')}"
+                    f" or set {self._printer.code('WANDB_MODE=online')}"
+                    " to enable cloud syncing.",
                 ]
             )
         else:
-            info = [f"Run data is saved locally in {printer.files(settings.sync_dir)}"]
-            if not printer.supports_html:
+            sync_dir = self._settings.sync_dir
+            info = [f"Run data is saved locally in {self._printer.files(sync_dir)}"]
+            if not self._printer.supports_html:
                 info.append(
-                    f"Run {printer.code('`wandb offline`')} to turn off syncing."
+                    f"Run {self._printer.code('`wandb offline`')} to turn off syncing."
                 )
-            if not settings.quiet and not settings.silent:
-                printer.display(info)
+            if not self._settings.quiet and not self._settings.silent:
+                self._printer.display(info)
+
+    def _header_run_info(self) -> None:
+        settings, printer = self._settings, self._printer
 
-    @staticmethod
-    def _header_run_info(
-        *,
-        settings: Settings,
-        printer: printer.Printer,
-    ) -> None:
         if settings._offline or settings.silent:
             return
 
@@ -3911,12 +4034,13 @@ class Run:
             return
 
         if printer.supports_html:
-            if not wandb.jupyter.maybe_display():  # type: ignore
+            import wandb.jupyter
+
+            if not wandb.jupyter.display_if_magic_is_used(self):
                 run_line = f"<strong>{printer.link(run_url, run_name)}</strong>"
                 project_line, sweep_line = "", ""
 
-                # TODO(settings): make settings the source of truth
-                if not wandb.jupyter.quiet():  # type: ignore
+                if not settings.quiet:
                     doc_html = printer.link(url_registry.url("developer-guide"), "docs")
 
                     project_html = printer.link(project_url, "Weights & Biases")