wandb 0.18.2__py3-none-win32.whl → 0.18.4__py3-none-win32.whl

wandb/sdk/wandb_run.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import _thread as thread
 import atexit
 import functools
@@ -18,20 +20,12 @@ 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,
-    Dict,
-    List,
-    NamedTuple,
-    Optional,
-    Sequence,
-    TextIO,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, Sequence, TextIO
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Literal
+else:
+    from typing import Literal
 
 import requests
 
@@ -69,7 +63,11 @@ from wandb.util import (
 )
 
 from . import wandb_config, wandb_metric, wandb_summary
-from .artifacts._validators import validate_aliases, validate_tags
+from .artifacts._validators import (
+    is_artifact_registry_project,
+    validate_aliases,
+    validate_tags,
+)
 from .data_types._dtypes import TypeRegistry
 from .interface.interface import FilesDict, GlobStr, InterfaceBase, PolicyName
 from .interface.summary_record import SummaryRecord
@@ -80,6 +78,8 @@ from .lib import (
     filesystem,
     ipython,
     module,
+    printer,
+    progress,
     proto_util,
     redirect,
     telemetry,
@@ -87,7 +87,6 @@ from .lib import (
 from .lib.exit_hooks import ExitHooks
 from .lib.gitlib import GitRepo
 from .lib.mailbox import MailboxError, MailboxHandle, MailboxProbe, MailboxProgress
-from .lib.printer import get_printer
 from .lib.proto_util import message_to_dict
 from .lib.reporting import Reporter
 from .lib.wburls import wburls
@@ -101,26 +100,27 @@ if TYPE_CHECKING:
     else:
         from typing_extensions import TypedDict
 
+    import torch  # type: ignore [import-not-found]
+
     import wandb.apis.public
     import wandb.sdk.backend.backend
     import wandb.sdk.interface.interface_queue
+    from wandb.data_types import Table
     from wandb.proto.wandb_internal_pb2 import (
         GetSummaryResponse,
         InternalMessagesResponse,
         SampledHistoryResponse,
     )
 
-    from .lib.printer import PrinterJupyter, PrinterTerm
-
     class GitSourceDict(TypedDict):
         remote: str
         commit: str
-        entrypoint: List[str]
+        entrypoint: list[str]
         args: Sequence[str]
 
     class ArtifactSourceDict(TypedDict):
         artifact: str
-        entrypoint: List[str]
+        entrypoint: list[str]
         args: Sequence[str]
 
     class ImageSourceDict(TypedDict):
@@ -130,10 +130,10 @@ if TYPE_CHECKING:
     class JobSourceDict(TypedDict, total=False):
         _version: str
         source_type: str
-        source: Union[GitSourceDict, ArtifactSourceDict, ImageSourceDict]
-        input_types: Dict[str, Any]
-        output_types: Dict[str, Any]
-        runtime: Optional[str]
+        source: GitSourceDict | ArtifactSourceDict | ImageSourceDict
+        input_types: dict[str, Any]
+        output_types: dict[str, Any]
+        runtime: str | None
 
 
 logger = logging.getLogger("wandb")
@@ -160,11 +160,11 @@ class RunStatusChecker:
     """
 
     _stop_status_lock: threading.Lock
-    _stop_status_handle: Optional[MailboxHandle]
+    _stop_status_handle: MailboxHandle | None
     _network_status_lock: threading.Lock
-    _network_status_handle: Optional[MailboxHandle]
+    _network_status_handle: MailboxHandle | None
     _internal_messages_lock: threading.Lock
-    _internal_messages_handle: Optional[MailboxHandle]
+    _internal_messages_handle: MailboxHandle | None
 
     def __init__(
         self,
@@ -212,7 +212,7 @@ class RunStatusChecker:
     @staticmethod
     def _abandon_status_check(
         lock: threading.Lock,
-        handle: Optional[MailboxHandle],
+        handle: MailboxHandle | None,
     ):
         with lock:
             if handle:
@@ -227,7 +227,7 @@ class RunStatusChecker:
         request: Any,
         process: Any,
     ) -> None:
-        local_handle: Optional[MailboxHandle] = None
+        local_handle: MailboxHandle | None = None
         join_requested = False
         while not join_requested:
             time_probe = time.monotonic()
@@ -365,7 +365,7 @@ class _run_decorator:  # noqa: N801
     @classmethod
     def _attach(cls, func: Callable) -> Callable:
         @functools.wraps(func)
-        def wrapper(self: Type["Run"], *args: Any, **kwargs: Any) -> Any:
+        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):
@@ -398,7 +398,7 @@ class _run_decorator:  # noqa: N801
     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:
+            def wrapper_fn(self: type[Run], *args: Any, **kwargs: Any) -> Any:
                 if not getattr(self, "_is_finished", False):
                     return func(self, *args, **kwargs)
 
@@ -419,7 +419,7 @@ class _run_decorator:  # noqa: N801
     @classmethod
     def _noop(cls, func: Callable) -> Callable:
         @functools.wraps(func)
-        def wrapper(self: Type["Run"], *args: Any, **kwargs: Any) -> Any:
+        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
@@ -458,7 +458,7 @@ class _run_decorator:  # noqa: N801
 class RunStatus:
     sync_items_total: int = field(default=0)
     sync_items_pending: int = field(default=0)
-    sync_time: Optional[datetime] = field(default=None)
+    sync_time: datetime | None = field(default=None)
 
 
 class Run:
@@ -528,67 +528,65 @@ class Run:
     _telemetry_obj_dirty: bool
     _telemetry_obj_flushed: bytes
 
-    _teardown_hooks: List[TeardownHook]
-    _tags: Optional[Tuple[Any, ...]]
+    _teardown_hooks: list[TeardownHook]
+    _tags: tuple[Any, ...] | None
 
-    _entity: Optional[str]
-    _project: Optional[str]
-    _group: Optional[str]
-    _job_type: Optional[str]
-    _name: Optional[str]
-    _notes: Optional[str]
-    _sweep_id: Optional[str]
+    _entity: str | None
+    _project: str | None
+    _group: str | None
+    _job_type: str | None
+    _name: str | None
+    _notes: str | None
+    _sweep_id: str | None
 
-    _run_obj: Optional[RunRecord]
+    _run_obj: RunRecord | None
     # Use string literal annotation because of type reference loop
-    _backend: Optional["wandb.sdk.backend.backend.Backend"]
-    _internal_run_interface: Optional[
-        "wandb.sdk.interface.interface_queue.InterfaceQueue"
-    ]
-    _wl: Optional[_WandbSetup]
-
-    _out_redir: Optional[redirect.RedirectBase]
-    _err_redir: Optional[redirect.RedirectBase]
-    _redirect_cb: Optional[Callable[[str, str], None]]
-    _redirect_raw_cb: Optional[Callable[[str, str], None]]
-    _output_writer: Optional["filesystem.CRDedupedFile"]
-    _quiet: Optional[bool]
+    _backend: wandb.sdk.backend.backend.Backend | None
+    _internal_run_interface: wandb.sdk.interface.interface_queue.InterfaceQueue | None
+    _wl: _WandbSetup | None
+
+    _out_redir: redirect.RedirectBase | None
+    _err_redir: redirect.RedirectBase | None
+    _redirect_cb: Callable[[str, str], None] | None
+    _redirect_raw_cb: Callable[[str, str], None] | None
+    _output_writer: filesystem.CRDedupedFile | None
+    _quiet: bool | None
 
     _atexit_cleanup_called: bool
-    _hooks: Optional[ExitHooks]
-    _exit_code: Optional[int]
+    _hooks: ExitHooks | None
+    _exit_code: int | None
 
-    _run_status_checker: Optional[RunStatusChecker]
+    _run_status_checker: RunStatusChecker | None
 
-    _sampled_history: Optional["SampledHistoryResponse"]
-    _final_summary: Optional["GetSummaryResponse"]
-    _poll_exit_handle: Optional[MailboxHandle]
-    _poll_exit_response: Optional[PollExitResponse]
-    _internal_messages_response: Optional["InternalMessagesResponse"]
+    _sampled_history: SampledHistoryResponse | None
+    _final_summary: GetSummaryResponse | None
+    _poll_exit_handle: MailboxHandle | None
+    _poll_exit_response: PollExitResponse | None
+    _internal_messages_response: InternalMessagesResponse | None
 
-    _stdout_slave_fd: Optional[int]
-    _stderr_slave_fd: Optional[int]
-    _artifact_slots: List[str]
+    _stdout_slave_fd: int | None
+    _stderr_slave_fd: int | None
+    _artifact_slots: list[str]
 
     _init_pid: int
     _attach_pid: int
-    _iface_pid: Optional[int]
-    _iface_port: Optional[int]
+    _iface_pid: int | None
+    _iface_port: int | None
 
-    _attach_id: Optional[str]
+    _attach_id: str | None
     _is_attached: bool
     _is_finished: bool
     _settings: Settings
 
-    _launch_artifacts: Optional[Dict[str, Any]]
-    _printer: Union["PrinterTerm", "PrinterJupyter"]
+    _launch_artifacts: dict[str, Any] | None
+    _printer: printer.Printer
 
     def __init__(
         self,
         settings: Settings,
-        config: Optional[Dict[str, Any]] = None,
-        sweep_config: Optional[Dict[str, Any]] = None,
-        launch_config: Optional[Dict[str, Any]] = None,
+        config: dict[str, Any] | None = None,
+        sweep_config: dict[str, Any] | None = None,
+        launch_config: dict[str, Any] | None = None,
     ) -> None:
         # pid is set, so we know if this run object was initialized by this process
         self._init_pid = os.getpid()
@@ -608,9 +606,9 @@ class Run:
     def _init(
         self,
         settings: Settings,
-        config: Optional[Dict[str, Any]] = None,
-        sweep_config: Optional[Dict[str, Any]] = None,
-        launch_config: Optional[Dict[str, Any]] = None,
+        config: dict[str, Any] | None = None,
+        sweep_config: dict[str, Any] | None = None,
+        launch_config: dict[str, Any] | None = None,
     ) -> None:
         self._settings = settings
 
@@ -626,7 +624,7 @@ class Run:
         )
         self.summary._set_update_callback(self._summary_update_callback)
         self._step = 0
-        self._torch_history: Optional[wandb_torch.TorchHistory] = None  # type: ignore
+        self._torch_history: wandb_torch.TorchHistory | None = None  # type: ignore
 
         # 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,
@@ -635,9 +633,9 @@ class Run:
 
         _datatypes_set_callback(self._datatypes_callback)
 
-        self._printer = get_printer(self._settings._jupyter)
+        self._printer = printer.get_printer(self._settings._jupyter)
         self._wl = None
-        self._reporter: Optional[Reporter] = None
+        self._reporter: Reporter | None = None
 
         self._entity = None
         self._project = None
@@ -663,7 +661,7 @@ class Run:
         self._quiet = self._settings.quiet
 
         self._output_writer = None
-        self._used_artifact_slots: Dict[str, str] = {}
+        self._used_artifact_slots: dict[str, str] = {}
 
         # Returned from backend request_run(), set from wandb_init?
         self._run_obj = None
@@ -699,8 +697,8 @@ class Run:
         config = config or dict()
         wandb_key = "_wandb"
         config.setdefault(wandb_key, dict())
-        self._launch_artifact_mapping: Dict[str, Any] = {}
-        self._unique_launch_artifact_sequence_names: Dict[str, Any] = {}
+        self._launch_artifact_mapping: dict[str, Any] = {}
+        self._unique_launch_artifact_sequence_names: dict[str, Any] = {}
         if self._settings.save_code and self._settings.program_relpath:
             config[wandb_key]["code_path"] = LogicalPath(
                 os.path.join("code", self._settings.program_relpath)
@@ -766,7 +764,7 @@ class Run:
     def _handle_launch_artifact_overrides(self) -> None:
         if self._settings.launch and (os.environ.get("WANDB_ARTIFACTS") is not None):
             try:
-                artifacts: Dict[str, Any] = json.loads(
+                artifacts: dict[str, Any] = json.loads(
                     os.environ.get("WANDB_ARTIFACTS", "{}")
                 )
             except (ValueError, SyntaxError):
@@ -786,7 +784,7 @@ class Run:
                 artifacts = launch_config.get("overrides").get("artifacts")
                 self._initialize_launch_artifact_maps(artifacts)
 
-    def _initialize_launch_artifact_maps(self, artifacts: Dict[str, Any]) -> None:
+    def _initialize_launch_artifact_maps(self, artifacts: dict[str, Any]) -> None:
         for key, item in artifacts.items():
             self._launch_artifact_mapping[key] = item
             artifact_sequence_tuple_or_slot = key.split(":")
@@ -893,7 +891,7 @@ class Run:
         except Exception:
             wandb.termwarn("Cannot find valid git repo associated with this directory.")
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> "Run":
+    def __deepcopy__(self, memo: dict[int, Any]) -> Run:
         return self
 
     def __getstate__(self) -> Any:
@@ -927,7 +925,7 @@ class Run:
         self.__dict__.update(state)
 
     @property
-    def _torch(self) -> "wandb_torch.TorchHistory":  # type: ignore
+    def _torch(self) -> wandb_torch.TorchHistory:  # type: ignore
         if self._torch_history is None:
             self._torch_history = wandb_torch.TorchHistory()  # type: ignore
         return self._torch_history
@@ -959,7 +957,7 @@ class Run:
 
     @property
     @_run_decorator._attach
-    def name(self) -> Optional[str]:
+    def name(self) -> str | None:
         """Display name of the run.
 
         Display names are not guaranteed to be unique and may be descriptive.
@@ -982,7 +980,7 @@ class Run:
 
     @property
     @_run_decorator._attach
-    def notes(self) -> Optional[str]:
+    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
@@ -1003,7 +1001,7 @@ class Run:
 
     @property
     @_run_decorator._attach
-    def tags(self) -> Optional[Tuple]:
+    def tags(self) -> tuple | None:
         """Tags associated with the run, if there are any."""
         if self._tags:
             return self._tags
@@ -1030,7 +1028,7 @@ class Run:
 
     @property
     @_run_decorator._attach
-    def sweep_id(self) -> Optional[str]:
+    def sweep_id(self) -> str | None:
         """ID of the sweep associated with the run, if there is one."""
         if not self._run_obj:
             return None
@@ -1090,6 +1088,7 @@ class Run:
         return self._step
 
     def project_name(self) -> str:
+        # TODO: deprecate this in favor of project
         return self._run_obj.project if self._run_obj else ""
 
     @property
@@ -1148,15 +1147,13 @@ class Run:
     @_run_decorator._attach
     def log_code(
         self,
-        root: Optional[str] = ".",
-        name: Optional[str] = None,
-        include_fn: Union[
-            Callable[[str, str], bool], Callable[[str], bool]
-        ] = _is_py_requirements_or_dockerfile,
-        exclude_fn: Union[
-            Callable[[str, str], bool], Callable[[str], bool]
-        ] = filenames.exclude_wandb_fn,
-    ) -> Optional[Artifact]:
+        root: str | None = ".",
+        name: str | None = None,
+        include_fn: Callable[[str, str], bool]
+        | Callable[[str], bool] = _is_py_requirements_or_dockerfile,
+        exclude_fn: Callable[[str, str], bool]
+        | Callable[[str], bool] = filenames.exclude_wandb_fn,
+    ) -> Artifact | None:
         """Save the current state of your code to a W&B Artifact.
 
         By default, it walks the current directory and logs all files that end with `.py`.
@@ -1229,7 +1226,7 @@ class Run:
 
         return self._log_artifact(art)
 
-    def get_url(self) -> Optional[str]:
+    def get_url(self) -> str | None:
         """Return the url for the W&B run, if there is one.
 
         Offline runs will not have a url.
@@ -1239,7 +1236,7 @@ class Run:
             return None
         return self._settings.run_url
 
-    def get_project_url(self) -> Optional[str]:
+    def get_project_url(self) -> str | None:
         """Return the url for the W&B project associated with the run, if there is one.
 
         Offline runs will not have a project url.
@@ -1249,7 +1246,7 @@ class Run:
             return None
         return self._settings.project_url
 
-    def get_sweep_url(self) -> Optional[str]:
+    def get_sweep_url(self) -> str | None:
         """Return the url for the sweep associated with the run, if there is one."""
         if self._settings._offline:
             wandb.termwarn("URL not available in offline run")
@@ -1258,7 +1255,7 @@ class Run:
 
     @property
     @_run_decorator._attach
-    def url(self) -> Optional[str]:
+    def url(self) -> str | None:
         """The W&B url associated with the run."""
         return self.get_url()
 
@@ -1273,9 +1270,9 @@ class Run:
 
     def _label_internal(
         self,
-        code: Optional[str] = None,
-        repo: Optional[str] = None,
-        code_version: Optional[str] = None,
+        code: str | None = None,
+        repo: str | None = None,
+        code_version: str | None = None,
     ) -> None:
         with telemetry.context(run=self) as tel:
             if code and RE_LABEL.match(code):
@@ -1287,9 +1284,9 @@ class Run:
 
     def _label(
         self,
-        code: Optional[str] = None,
-        repo: Optional[str] = None,
-        code_version: Optional[str] = None,
+        code: str | None = None,
+        repo: str | None = None,
+        code_version: str | None = None,
         **kwargs: str,
     ) -> None:
         if self._settings.label_disable:
@@ -1311,7 +1308,7 @@ class Run:
         # update telemetry in the backend immediately for _label() callers
         self._telemetry_flush()
 
-    def _label_probe_lines(self, lines: List[str]) -> None:
+    def _label_probe_lines(self, lines: list[str]) -> None:
         if not lines:
             return
         parsed = telemetry._parse_label_lines(lines)
@@ -1379,23 +1376,23 @@ class Run:
         return prefix + f"<iframe src={url!r} style={style!r}></iframe>"
 
     def _repr_mimebundle_(
-        self, include: Optional[Any] = None, exclude: Optional[Any] = None
-    ) -> Dict[str, str]:
+        self, include: Any | None = None, exclude: Any | None = None
+    ) -> dict[str, str]:
         return {"text/html": self.to_html(hidden=True)}
 
     @_run_decorator._noop_on_finish()
     def _config_callback(
         self,
-        key: Optional[Union[Tuple[str, ...], str]] = None,
-        val: Optional[Any] = None,
-        data: Optional[Dict[str, object]] = None,
+        key: tuple[str, ...] | str | None = None,
+        val: Any | None = None,
+        data: dict[str, object] | None = None,
     ) -> None:
         logger.info(f"config_cb {key} {val} {data}")
         if self._backend and self._backend.interface:
             self._backend.interface.publish_config(key=key, val=val, data=data)
 
     def _config_artifact_callback(
-        self, key: str, val: Union[str, Artifact, dict]
+        self, key: str, val: str | Artifact | dict
     ) -> Artifact:
         # artifacts can look like dicts as they are passed into the run config
         # since the run config stores them on the backend as a dict with fields shown
@@ -1446,7 +1443,7 @@ class Run:
         # line = "Waiting for run.summary data..."
         # self._printer.display(line)
 
-    def _summary_get_current_summary_callback(self) -> Dict[str, Any]:
+    def _summary_get_current_summary_callback(self) -> dict[str, Any]:
         if self._is_finished:
             # TODO: WB-18420: fetch summary from backend and stage it before run is finished
             wandb.termwarn("Summary data not available in finished run")
@@ -1473,7 +1470,7 @@ class Run:
         files: FilesDict = dict(files=[(GlobStr(glob.escape(fname)), "now")])
         self._backend.interface.publish_files(files)
 
-    def _visualization_hack(self, row: Dict[str, Any]) -> Dict[str, Any]:
+    def _visualization_hack(self, row: dict[str, Any]) -> dict[str, Any]:
         # TODO(jhr): move visualize hack somewhere else
         chart_keys = set()
         split_table_set = set()
@@ -1510,9 +1507,9 @@ class Run:
 
     def _partial_history_callback(
         self,
-        row: Dict[str, Any],
-        step: Optional[int] = None,
-        commit: Optional[bool] = None,
+        row: dict[str, Any],
+        step: int | None = None,
+        commit: bool | None = None,
     ) -> None:
         row = row.copy()
         if row:
@@ -1559,19 +1556,19 @@ class Run:
     def _set_library(self, library: _WandbSetup) -> None:
         self._wl = library
 
-    def _set_backend(self, backend: "wandb.sdk.backend.backend.Backend") -> None:
+    def _set_backend(self, backend: wandb.sdk.backend.backend.Backend) -> None:
         self._backend = backend
 
     def _set_internal_run_interface(
         self,
-        interface: "wandb.sdk.interface.interface_queue.InterfaceQueue",
+        interface: wandb.sdk.interface.interface_queue.InterfaceQueue,
     ) -> None:
         self._internal_run_interface = interface
 
     def _set_reporter(self, reporter: Reporter) -> None:
         self._reporter = reporter
 
-    def _set_teardown_hooks(self, hooks: List[TeardownHook]) -> None:
+    def _set_teardown_hooks(self, hooks: list[TeardownHook]) -> None:
         self._teardown_hooks = hooks
 
     def _set_run_obj(self, run_obj: RunRecord) -> None:
@@ -1609,7 +1606,7 @@ class Run:
         )
 
     def _add_singleton(
-        self, data_type: str, key: str, value: Dict[Union[int, str], str]
+        self, data_type: str, key: str, value: dict[int | str, str]
     ) -> None:
         """Store a singleton item to wandb config.
 
@@ -1639,9 +1636,9 @@ class Run:
 
     def _log(
         self,
-        data: Dict[str, Any],
-        step: Optional[int] = None,
-        commit: Optional[bool] = None,
+        data: dict[str, Any],
+        step: int | None = None,
+        commit: bool | None = None,
     ) -> None:
         if not isinstance(data, Mapping):
             raise ValueError("wandb.log must be passed a dictionary")
@@ -1680,10 +1677,10 @@ class Run:
     @_run_decorator._attach
     def log(
         self,
-        data: Dict[str, Any],
-        step: Optional[int] = None,
-        commit: Optional[bool] = None,
-        sync: Optional[bool] = None,
+        data: dict[str, Any],
+        step: int | None = None,
+        commit: bool | None = None,
+        sync: bool | None = None,
     ) -> None:
         """Upload run data.
 
@@ -1936,10 +1933,10 @@ class Run:
     @_run_decorator._attach
     def save(
         self,
-        glob_str: Optional[Union[str, os.PathLike]] = None,
-        base_path: Optional[Union[str, os.PathLike]] = None,
+        glob_str: str | os.PathLike | None = None,
+        base_path: str | os.PathLike | None = None,
         policy: PolicyName = "live",
-    ) -> Union[bool, List[str]]:
+    ) -> bool | list[str]:
         """Sync one or more files to W&B.
 
         Relative paths are relative to the current working directory.
@@ -2044,8 +2041,8 @@ class Run:
         self,
         glob_path: pathlib.PurePath,
         base_path: pathlib.PurePath,
-        policy: "PolicyName",
-    ) -> List[str]:
+        policy: PolicyName,
+    ) -> list[str]:
         # Can't use is_relative_to() because that's added in Python 3.9,
         # but we support down to Python 3.7.
         if not str(glob_path).startswith(str(base_path)):
@@ -2128,10 +2125,10 @@ class Run:
     def restore(
         self,
         name: str,
-        run_path: Optional[str] = None,
+        run_path: str | None = None,
         replace: bool = False,
-        root: Optional[str] = None,
-    ) -> Union[None, TextIO]:
+        root: str | None = None,
+    ) -> None | TextIO:
         return restore(
             name,
             run_path or self._get_path(),
@@ -2141,9 +2138,7 @@ class Run:
 
     @_run_decorator._noop
     @_run_decorator._attach
-    def finish(
-        self, exit_code: Optional[int] = None, quiet: Optional[bool] = None
-    ) -> None:
+    def finish(self, exit_code: int | None = None, quiet: bool | None = None) -> None:
         """Mark a run as finished, and finish uploading all data.
 
         This is used when creating multiple runs in the same process. We automatically
@@ -2157,8 +2152,8 @@ class Run:
 
     def _finish(
         self,
-        exit_code: Optional[int] = None,
-        quiet: Optional[bool] = None,
+        exit_code: int | None = None,
+        quiet: bool | None = None,
     ) -> None:
         logger.info(f"finishing run {self._get_path()}")
         with telemetry.context(run=self) as tel:
@@ -2209,7 +2204,7 @@ class Run:
 
     @_run_decorator._noop
     @_run_decorator._attach
-    def join(self, exit_code: Optional[int] = None) -> None:
+    def join(self, exit_code: int | None = None) -> None:
         """Deprecated alias for `finish()` - use finish instead."""
         if hasattr(self, "_telemetry_obj"):
             deprecate.deprecate(
@@ -2248,10 +2243,10 @@ class Run:
     @staticmethod
     def plot_table(
         vega_spec_name: str,
-        data_table: "wandb.Table",
-        fields: Dict[str, Any],
-        string_fields: Optional[Dict[str, Any]] = None,
-        split_table: Optional[bool] = False,
+        data_table: Table,
+        fields: dict[str, Any],
+        string_fields: dict[str, Any] | None = None,
+        split_table: bool | None = False,
     ) -> CustomChart:
         """Create a custom plot on a table.
 
@@ -2263,6 +2258,8 @@ class Run:
                 visualization needs
             string_fields: a dict that provides values for any string constants
                 the custom visualization needs
+            split_table: a boolean that indicates whether the table should be in
+                a separate section in the UI
         """
         return custom_chart(
             vega_spec_name, data_table, fields, string_fields or {}, split_table
@@ -2289,6 +2286,8 @@ class Run:
             define_metric=self.define_metric,
             plot_table=self.plot_table,
             alert=self.alert,
+            watch=self.watch,
+            unwatch=self.unwatch,
             mark_preempting=self.mark_preempting,
             log_model=self.log_model,
             use_model=self.use_model,
@@ -2297,9 +2296,9 @@ class Run:
 
     def _redirect(
         self,
-        stdout_slave_fd: Optional[int],
-        stderr_slave_fd: Optional[int],
-        console: Optional[str] = None,
+        stdout_slave_fd: int | None,
+        stderr_slave_fd: int | None,
+        console: str | None = None,
     ) -> None:
         if console is None:
             console = self._settings.console
@@ -2414,7 +2413,7 @@ class Run:
             self._err_redir.uninstall()
         logger.info("restore done")
 
-    def _atexit_cleanup(self, exit_code: Optional[int] = None) -> None:
+    def _atexit_cleanup(self, exit_code: int | None = None) -> None:
         if self._backend is None:
             logger.warning("process exited without backend configured")
             return
@@ -2525,7 +2524,7 @@ class Run:
         self,
     ) -> None:
         def _telemetry_import_hook(
-            run: "Run",
+            run: Run,
             module: Any,
         ) -> None:
             with telemetry.context(run=run) as tel:
@@ -2568,7 +2567,7 @@ class Run:
 
         StagedLaunchInputs().apply(self)
 
-    def _make_job_source_reqs(self) -> Tuple[List[str], Dict[str, Any], Dict[str, Any]]:
+    def _make_job_source_reqs(self) -> tuple[list[str], dict[str, Any], dict[str, Any]]:
         from wandb.util import working_set
 
         installed_packages_list = sorted(f"{d.key}=={d.version}" for d in working_set())
@@ -2580,10 +2579,10 @@ class Run:
     def _construct_job_artifact(
         self,
         name: str,
-        source_dict: "JobSourceDict",
-        installed_packages_list: List[str],
-        patch_path: Optional[os.PathLike] = None,
-    ) -> "Artifact":
+        source_dict: JobSourceDict,
+        installed_packages_list: list[str],
+        patch_path: os.PathLike | None = None,
+    ) -> Artifact:
         job_artifact = job_builder.JobArtifact(name)
         if patch_path and os.path.exists(patch_path):
             job_artifact.add_file(FilePathStr(str(patch_path)), "diff.patch")
@@ -2596,12 +2595,12 @@ class Run:
 
     def _create_image_job(
         self,
-        input_types: Dict[str, Any],
-        output_types: Dict[str, Any],
-        installed_packages_list: List[str],
-        docker_image_name: Optional[str] = None,
-        args: Optional[List[str]] = None,
-    ) -> Optional["Artifact"]:
+        input_types: dict[str, Any],
+        output_types: dict[str, Any],
+        installed_packages_list: list[str],
+        docker_image_name: str | None = None,
+        args: list[str] | None = None,
+    ) -> Artifact | None:
         docker_image_name = docker_image_name or os.getenv("WANDB_DOCKER")
 
         if not docker_image_name:
@@ -2624,7 +2623,7 @@ class Run:
         return job_artifact
 
     def _log_job_artifact_with_image(
-        self, docker_image_name: str, args: Optional[List[str]] = None
+        self, docker_image_name: str, args: list[str] | None = None
     ) -> Artifact:
         packages, in_types, out_types = self._make_job_source_reqs()
         job_artifact = self._create_image_job(
@@ -2653,16 +2652,20 @@ class Run:
         handle = self._backend.interface.deliver_poll_exit()
         probe_handle.set_mailbox_handle(handle)
 
-    def _on_progress_exit(self, progress_handle: MailboxProgress) -> None:
+    def _on_progress_exit(
+        self,
+        progress_printer: progress.ProgressPrinter,
+        progress_handle: MailboxProgress,
+    ) -> None:
         probe_handles = progress_handle.get_probe_handles()
-        assert probe_handles and len(probe_handles) == 1
+        if not probe_handles or len(probe_handles) != 1:
+            return
 
         result = probe_handles[0].get_probe_result()
         if not result:
             return
-        self._footer_file_pusher_status_info(
-            result.response.poll_exit_response, printer=self._printer
-        )
+
+        progress_printer.update([result.response.poll_exit_response])
 
     def _on_finish(self) -> None:
         trigger.call("on_finished")
@@ -2677,16 +2680,28 @@ class Run:
         exit_handle = self._backend.interface.deliver_exit(self._exit_code)
         exit_handle.add_probe(on_probe=self._on_probe_exit)
 
-        # wait for the exit to complete
-        _ = exit_handle.wait(timeout=-1, on_progress=self._on_progress_exit)
+        with progress.progress_printer(
+            self._printer,
+            self._settings,
+        ) as progress_printer:
+            # Wait for the run to complete.
+            _ = exit_handle.wait(
+                timeout=-1,
+                on_progress=functools.partial(
+                    self._on_progress_exit,
+                    progress_printer,
+                ),
+            )
 
+        # Print some final statistics.
         poll_exit_handle = self._backend.interface.deliver_poll_exit()
-        # wait for them, it's ok to do this serially but this can be improved
         result = poll_exit_handle.wait(timeout=-1)
         assert result
-        self._footer_file_pusher_status_info(
-            result.response.poll_exit_response, printer=self._printer
+        progress.print_sync_dedupe_stats(
+            self._printer,
+            result.response.poll_exit_response,
         )
+
         self._poll_exit_response = result.response.poll_exit_response
         internal_messages_handle = self._backend.interface.deliver_internal_messages()
         result = internal_messages_handle.wait(timeout=-1)
@@ -2727,12 +2742,12 @@ class Run:
     def define_metric(
         self,
         name: str,
-        step_metric: Union[str, wandb_metric.Metric, None] = None,
-        step_sync: Optional[bool] = None,
-        hidden: Optional[bool] = None,
-        summary: Optional[str] = None,
-        goal: Optional[str] = None,
-        overwrite: Optional[bool] = None,
+        step_metric: str | wandb_metric.Metric | None = None,
+        step_sync: bool | None = None,
+        hidden: bool | None = None,
+        summary: str | None = None,
+        goal: str | None = None,
+        overwrite: bool | None = None,
     ) -> wandb_metric.Metric:
         """Customize metrics logged with `wandb.log()`.
 
@@ -2788,12 +2803,12 @@ class Run:
     def _define_metric(
         self,
         name: str,
-        step_metric: Union[str, wandb_metric.Metric, None] = None,
-        step_sync: Optional[bool] = None,
-        hidden: Optional[bool] = None,
-        summary: Optional[str] = None,
-        goal: Optional[str] = None,
-        overwrite: Optional[bool] = None,
+        step_metric: str | wandb_metric.Metric | None = None,
+        step_sync: bool | None = None,
+        hidden: bool | None = None,
+        summary: str | None = None,
+        goal: str | None = None,
+        overwrite: bool | None = None,
     ) -> wandb_metric.Metric:
         if not name:
             raise wandb.Error("define_metric() requires non-empty name argument")
@@ -2819,7 +2834,7 @@ class Run:
             raise wandb.Error(
                 f"Unhandled define_metric() arg: name (glob suffixes only): {name}"
             )
-        summary_ops: Optional[Sequence[str]] = None
+        summary_ops: Sequence[str] | None = None
         if summary:
             summary_items = [s.lower() for s in summary.split(",")]
             summary_ops = []
@@ -2832,7 +2847,7 @@ class Run:
             with telemetry.context(run=self) as tel:
                 tel.feature.metric_summary = True
         # TODO: deprecate goal
-        goal_cleaned: Optional[str] = None
+        goal_cleaned: str | None = None
         if goal is not None:
             goal_cleaned = goal[:3].lower()
             valid_goal = {"min", "max"}
@@ -2863,26 +2878,57 @@ class Run:
         m._commit()
         return m
 
-    # TODO(jhr): annotate this
     @_run_decorator._attach
-    def watch(  # type: ignore
+    def watch(
         self,
-        models,
-        criterion=None,
-        log="gradients",
-        log_freq=100,
-        idx=None,
-        log_graph=False,
+        models: torch.nn.Module | Sequence[torch.nn.Module],
+        criterion: torch.F | None = None,
+        log: Literal["gradients", "parameters", "all"] | None = "gradients",
+        log_freq: int = 1000,
+        idx: int | None = None,
+        log_graph: bool = False,
     ) -> None:
-        wandb.watch(models, criterion, log, log_freq, idx, log_graph)  # type: ignore
+        """Hooks into the given PyTorch model(s) to monitor gradients and the model's computational graph.
+
+        This function can track parameters, gradients, or both during training. It should be
+        extended to support arbitrary machine learning models in the future.
+
+        Args:
+            models (Union[torch.nn.Module, Sequence[torch.nn.Module]]):
+                A single model or a sequence of models to be monitored.
+            criterion (Optional[torch.F]):
+                The loss function being optimized (optional).
+            log (Optional[Literal["gradients", "parameters", "all"]]):
+                Specifies whether to log "gradients", "parameters", or "all".
+                Set to None to disable logging. (default="gradients")
+            log_freq (int):
+                Frequency (in batches) to log gradients and parameters. (default=1000)
+            idx (Optional[int]):
+                Index used when tracking multiple models with `wandb.watch`. (default=None)
+            log_graph (bool):
+                Whether to log the model's computational graph. (default=False)
+
+        Raises:
+            ValueError:
+                If `wandb.init` has not been called or if any of the models are not instances
+                of `torch.nn.Module`.
+        """
+        wandb.sdk._watch(self, models, criterion, log, log_freq, idx, log_graph)
 
-    # TODO(jhr): annotate this
     @_run_decorator._attach
-    def unwatch(self, models=None) -> None:  # type: ignore
-        wandb.unwatch(models=models)  # type: ignore
+    def unwatch(
+        self, models: torch.nn.Module | Sequence[torch.nn.Module] | None = None
+    ) -> None:
+        """Remove pytorch model topology, gradient and parameter hooks.
+
+        Args:
+            models (torch.nn.Module | Sequence[torch.nn.Module]):
+                Optional list of pytorch models that have had watch called on them
+        """
+        wandb.sdk._unwatch(self, models=models)
 
     # TODO(kdg): remove all artifact swapping logic
-    def _swap_artifact_name(self, artifact_name: str, use_as: Optional[str]) -> str:
+    def _swap_artifact_name(self, artifact_name: str, use_as: str | None) -> str:
         artifact_key_string = use_as or artifact_name
         replacement_artifact_info = self._launch_artifact_mapping.get(
             artifact_key_string
@@ -2925,7 +2971,7 @@ class Run:
         self,
         artifact: Artifact,
         target_path: str,
-        aliases: Optional[List[str]] = None,
+        aliases: list[str] | None = None,
     ) -> None:
         """Link the given artifact to a portfolio (a promoted collection of artifacts).
 
@@ -2947,41 +2993,54 @@ class Run:
         if aliases is None:
             aliases = []
 
-        if self._backend and self._backend.interface:
-            if artifact.is_draft() and not artifact._is_draft_save_started():
-                artifact = self._log_artifact(artifact)
-            if not self._settings._offline:
-                handle = self._backend.interface.deliver_link_artifact(
-                    self,
-                    artifact,
-                    portfolio,
-                    aliases,
-                    entity,
-                    project,
-                )
-                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(timeout=-1)
-                if result is None:
-                    handle.abandon()
-                else:
-                    response = result.response.link_artifact_response
-                    if response.error_message:
-                        wandb.termerror(response.error_message)
-            else:
-                # TODO: implement offline mode + sync
-                raise NotImplementedError
+        if not self._backend or not self._backend.interface:
+            return
+
+        if artifact.is_draft() and not artifact._is_draft_save_started():
+            artifact = self._log_artifact(artifact)
+
+        if self._settings._offline:
+            # 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
+            # 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
+        handle = self._backend.interface.deliver_link_artifact(
+            self,
+            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(timeout=-1)
+        if result is None:
+            handle.abandon()
+        else:
+            response = result.response.link_artifact_response
+            if response.error_message:
+                wandb.termerror(response.error_message)
 
     @_run_decorator._noop_on_finish()
     @_run_decorator._attach
     def use_artifact(
         self,
-        artifact_or_name: Union[str, Artifact],
-        type: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
-        use_as: Optional[str] = None,
+        artifact_or_name: str | Artifact,
+        type: str | None = None,
+        aliases: list[str] | None = None,
+        use_as: str | None = None,
     ) -> Artifact:
         """Declare an artifact as an input to a run.
 
@@ -2989,8 +3048,9 @@ class Run:
 
         Arguments:
             artifact_or_name: (str or Artifact) An artifact name.
-                May be prefixed with entity/project/. Valid names
-                can be in the following forms:
+                May be prefixed with project/ or entity/project/.
+                If no entity is specified in the name, the Run or API setting's entity is used.
+                Valid names can be in the following forms:
                     - name:version
                     - name:alias
                 You can also pass an Artifact object created by calling `wandb.Artifact`
@@ -3087,11 +3147,11 @@ class Run:
     @_run_decorator._attach
     def log_artifact(
         self,
-        artifact_or_path: Union[Artifact, StrPath],
-        name: Optional[str] = None,
-        type: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
-        tags: Optional[List[str]] = None,
+        artifact_or_path: Artifact | StrPath,
+        name: str | None = None,
+        type: str | None = None,
+        aliases: list[str] | None = None,
+        tags: list[str] | None = None,
     ) -> Artifact:
         """Declare an artifact as an output of a run.
 
@@ -3129,11 +3189,11 @@ class Run:
     @_run_decorator._attach
     def upsert_artifact(
         self,
-        artifact_or_path: Union[Artifact, str],
-        name: Optional[str] = None,
-        type: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
-        distributed_id: Optional[str] = None,
+        artifact_or_path: Artifact | str,
+        name: str | None = None,
+        type: str | None = None,
+        aliases: list[str] | None = None,
+        distributed_id: str | None = None,
     ) -> Artifact:
         """Declare (or append to) a non-finalized artifact as output of a run.
 
@@ -3183,11 +3243,11 @@ class Run:
     @_run_decorator._attach
     def finish_artifact(
         self,
-        artifact_or_path: Union[Artifact, str],
-        name: Optional[str] = None,
-        type: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
-        distributed_id: Optional[str] = None,
+        artifact_or_path: Artifact | str,
+        name: str | None = None,
+        type: str | None = None,
+        aliases: list[str] | None = None,
+        distributed_id: str | None = None,
     ) -> Artifact:
         """Finishes a non-finalized artifact as output of a run.
 
@@ -3235,12 +3295,12 @@ class Run:
 
     def _log_artifact(
         self,
-        artifact_or_path: Union[Artifact, StrPath],
-        name: Optional[str] = None,
-        type: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
-        tags: Optional[List[str]] = None,
-        distributed_id: Optional[str] = None,
+        artifact_or_path: Artifact | StrPath,
+        name: str | None = None,
+        type: str | None = None,
+        aliases: list[str] | None = None,
+        tags: list[str] | None = None,
+        distributed_id: str | None = None,
         finalize: bool = True,
         is_user_created: bool = False,
         use_after_commit: bool = False,
@@ -3301,7 +3361,7 @@ class Run:
             )
         return artifact
 
-    def _public_api(self, overrides: Optional[Dict[str, str]] = None) -> PublicApi:
+    def _public_api(self, overrides: dict[str, str] | None = None) -> PublicApi:
         overrides = {"run": self._run_id}
         if not (self._settings._offline or self._run_obj is None):
             overrides["entity"] = self._run_obj.entity
@@ -3342,11 +3402,11 @@ class Run:
 
     def _prepare_artifact(
         self,
-        artifact_or_path: Union[Artifact, StrPath],
-        name: Optional[str] = None,
-        type: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
-    ) -> Tuple[Artifact, List[str]]:
+        artifact_or_path: Artifact | StrPath,
+        name: str | None = None,
+        type: str | None = None,
+        aliases: list[str] | None = None,
+    ) -> tuple[Artifact, list[str]]:
         if isinstance(artifact_or_path, (str, os.PathLike)):
             name = name or f"run-{self._run_id}-{os.path.basename(artifact_or_path)}"
             artifact = wandb.Artifact(name, type or "unspecified")
@@ -3377,8 +3437,8 @@ class Run:
     def log_model(
         self,
         path: StrPath,
-        name: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
+        name: str | None = None,
+        aliases: list[str] | None = None,
     ) -> None:
         """Logs a model artifact containing the contents inside the 'path' to a run and marks it as an output to this run.
 
@@ -3482,8 +3542,8 @@ class Run:
         self,
         path: StrPath,
         registered_model_name: str,
-        name: Optional[str] = None,
-        aliases: Optional[List[str]] = None,
+        name: str | None = None,
+        aliases: list[str] | None = None,
     ) -> None:
         """Log a model artifact version and link it to a registered model in the model registry.
 
@@ -3576,8 +3636,8 @@ class Run:
         self,
         title: str,
         text: str,
-        level: Optional[Union[str, "AlertLevel"]] = None,
-        wait_duration: Union[int, float, timedelta, None] = None,
+        level: str | AlertLevel | None = None,
+        wait_duration: int | float | timedelta | None = None,
     ) -> None:
         """Launch an alert with the given title and text.
 
@@ -3605,12 +3665,12 @@ class Run:
         if self._backend and self._backend.interface:
             self._backend.interface.publish_alert(title, text, level_str, wait_duration)
 
-    def __enter__(self) -> "Run":
+    def __enter__(self) -> Run:
         return self
 
     def __exit__(
         self,
-        exc_type: Type[BaseException],
+        exc_type: type[BaseException],
         exc_val: BaseException,
         exc_tb: TracebackType,
     ) -> bool:
@@ -3634,7 +3694,7 @@ class Run:
     @property
     @_run_decorator._noop_on_finish()
     @_run_decorator._attach
-    def _system_metrics(self) -> Dict[str, List[Tuple[datetime, float]]]:
+    def _system_metrics(self) -> dict[str, list[tuple[datetime, float]]]:
         """Returns a dictionary of system metrics.
 
         Returns:
@@ -3643,7 +3703,7 @@ class Run:
 
         def pb_to_dict(
             system_metrics_pb: wandb.proto.wandb_internal_pb2.GetSystemMetricsResponse,
-        ) -> Dict[str, List[Tuple[datetime, float]]]:
+        ) -> dict[str, list[tuple[datetime, float]]]:
             res = {}
 
             for metric, records in system_metrics_pb.system_metrics.items():
@@ -3684,8 +3744,8 @@ class Run:
     @staticmethod
     def _header(
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         Run._header_wandb_version_info(settings=settings, printer=printer)
         Run._header_sync_info(settings=settings, printer=printer)
@@ -3694,22 +3754,20 @@ class Run:
     @staticmethod
     def _header_wandb_version_info(
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         if settings.quiet or settings.silent:
             return
 
         # TODO: add this to a higher verbosity level
-        printer.display(
-            f"Tracking run with wandb version {wandb.__version__}", off=False
-        )
+        printer.display(f"Tracking run with wandb version {wandb.__version__}")
 
     @staticmethod
     def _header_sync_info(
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         if settings._offline:
             printer.display(
@@ -3721,17 +3779,18 @@ class Run:
             )
         else:
             info = [f"Run data is saved locally in {printer.files(settings.sync_dir)}"]
-            if not printer._html:
+            if not printer.supports_html:
                 info.append(
                     f"Run {printer.code('`wandb offline`')} to turn off syncing."
                 )
-            printer.display(info, off=settings.quiet or settings.silent)
+            if not settings.quiet and not settings.silent:
+                printer.display(info)
 
     @staticmethod
     def _header_run_info(
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         if settings._offline or settings.silent:
             return
@@ -3749,7 +3808,7 @@ class Run:
         if not run_name:
             return
 
-        if printer._html:
+        if printer.supports_html:
             if not wandb.jupyter.maybe_display():  # type: ignore
                 run_line = f"<strong>{printer.link(run_url, run_name)}</strong>"
                 project_line, sweep_line = "", ""
@@ -3768,10 +3827,8 @@ class Run:
                     [f"{run_state_str} {run_line} {project_line}", sweep_line],
                 )
 
-        else:
-            printer.display(
-                f"{run_state_str} {printer.name(run_name)}", off=not run_name
-            )
+        elif run_name:
+            printer.display(f"{run_state_str} {printer.name(run_name)}")
 
         if not settings.quiet:
             # TODO: add verbosity levels and add this to higher levels
@@ -3787,11 +3844,13 @@ class Run:
         )
 
         # TODO(settings) use `wandb_settings` (if self.settings.anonymous == "true":)
-        if Api().api.settings().get("anonymous") == "true":
+        if run_name and Api().api.settings().get("anonymous") == "true":
             printer.display(
-                "Do NOT share these links with anyone. They can be used to claim your runs.",
+                (
+                    "Do NOT share these links with anyone."
+                    " They can be used to claim your runs."
+                ),
                 level="warn",
-                off=not run_name,
             )
 
     # ------------------------------------------------------------------------------
@@ -3801,15 +3860,15 @@ class Run:
     # with the service execution path that doesn't have access to the run instance
     @staticmethod
     def _footer(
-        sampled_history: Optional["SampledHistoryResponse"] = None,
-        final_summary: Optional["GetSummaryResponse"] = None,
-        poll_exit_response: Optional[PollExitResponse] = None,
-        internal_messages_response: Optional["InternalMessagesResponse"] = None,
-        reporter: Optional[Reporter] = None,
-        quiet: Optional[bool] = None,
+        sampled_history: SampledHistoryResponse | None = None,
+        final_summary: GetSummaryResponse | None = None,
+        poll_exit_response: PollExitResponse | None = None,
+        internal_messages_response: InternalMessagesResponse | None = None,
+        reporter: Reporter | None = None,
+        quiet: bool | None = None,
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         Run._footer_history_summary_info(
             history=sampled_history,
@@ -3841,177 +3900,51 @@ class Run:
             reporter=reporter, quiet=quiet, settings=settings, printer=printer
         )
 
-    # fixme: Temporary hack until we move to rich which allows multiple spinners
     @staticmethod
-    def _footer_file_pusher_status_info(
-        poll_exit_responses: Optional[
-            Union[PollExitResponse, List[Optional[PollExitResponse]]]
-        ] = None,
-        *,
-        printer: Union["PrinterTerm", "PrinterJupyter"],
-    ) -> None:
-        if not poll_exit_responses:
-            return
-        if isinstance(poll_exit_responses, PollExitResponse):
-            Run._footer_single_run_file_pusher_status_info(
-                poll_exit_responses, printer=printer
-            )
-        elif isinstance(poll_exit_responses, list):
-            poll_exit_responses_list = poll_exit_responses
-            assert all(
-                response is None or isinstance(response, PollExitResponse)
-                for response in poll_exit_responses_list
-            )
-            if len(poll_exit_responses_list) == 0:
-                return
-            elif len(poll_exit_responses_list) == 1:
-                Run._footer_single_run_file_pusher_status_info(
-                    poll_exit_responses_list[0], printer=printer
-                )
-            else:
-                Run._footer_multiple_runs_file_pusher_status_info(
-                    poll_exit_responses_list, printer=printer
-                )
-        else:
-            logger.error(
-                f"Got the type `{type(poll_exit_responses)}` for `poll_exit_responses`. "
-                "Expected either None, PollExitResponse or a List[Union[PollExitResponse, None]]"
-            )
-
-    @staticmethod
-    def _footer_single_run_file_pusher_status_info(
-        poll_exit_response: Optional[PollExitResponse] = None,
+    def _footer_sync_info(
+        poll_exit_response: PollExitResponse | None = None,
+        quiet: bool | None = None,
         *,
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
-        # todo: is this same as settings._offline?
-        if not poll_exit_response:
+        if settings.silent:
             return
 
-        stats = poll_exit_response.pusher_stats
-
-        megabyte = wandb.util.POW_2_BYTES[2][1]
-        line = (
-            f"{stats.uploaded_bytes / megabyte:.3f} MB"
-            f" of {stats.total_bytes / megabyte:.3f} MB uploaded"
-        )
-        if stats.deduped_bytes > 0:
-            line += f" ({stats.deduped_bytes / megabyte:.3f} MB deduped)"
-        line += "\r"
-
-        if stats.total_bytes > 0:
-            printer.progress_update(line, stats.uploaded_bytes / stats.total_bytes)
-        else:
-            printer.progress_update(line, 1.0)
-
-        if poll_exit_response.done:
-            printer.progress_close()
-
-            if stats.total_bytes > 0:
-                dedupe_fraction = stats.deduped_bytes / float(stats.total_bytes)
-            else:
-                dedupe_fraction = 0
-
-            if stats.deduped_bytes > 0.01:
+        if settings._offline:
+            if not quiet and not settings.quiet:
                 printer.display(
-                    f"W&B sync reduced upload amount by {dedupe_fraction:.1%}"
+                    [
+                        "You can sync this run to the cloud by running:",
+                        printer.code(f"wandb sync {settings.sync_dir}"),
+                    ],
                 )
-
-    @staticmethod
-    def _footer_multiple_runs_file_pusher_status_info(
-        poll_exit_responses: List[Optional[PollExitResponse]],
-        *,
-        printer: Union["PrinterTerm", "PrinterJupyter"],
-    ) -> None:
-        # todo: is this same as settings._offline?
-        if not all(poll_exit_responses):
             return
 
-        megabyte = wandb.util.POW_2_BYTES[2][1]
-        total_files: int = sum(
-            sum(
-                [
-                    response.file_counts.wandb_count,
-                    response.file_counts.media_count,
-                    response.file_counts.artifact_count,
-                    response.file_counts.other_count,
-                ]
+        info = []
+        if settings.run_name and settings.run_url:
+            info.append(
+                f"{printer.emoji('rocket')} View run {printer.name(settings.run_name)} at: {printer.link(settings.run_url)}"
             )
-            for response in poll_exit_responses
-            if response is not None and response.file_counts is not None
-        )
-        uploaded = sum(
-            response.pusher_stats.uploaded_bytes
-            for response in poll_exit_responses
-            if response is not None and response.pusher_stats is not None
-        )
-        total = sum(
-            response.pusher_stats.total_bytes
-            for response in poll_exit_responses
-            if response is not None and response.pusher_stats is not None
-        )
-
-        line = (
-            f"Processing {len(poll_exit_responses)} runs with {total_files} files "
-            f"({uploaded/megabyte :.2f} MB/{total/megabyte :.2f} MB)\r"
-        )
-        # line = "{}{:<{max_len}}\r".format(line, " ", max_len=(80 - len(line)))
-        printer.progress_update(line)  # type:ignore[call-arg]
-
-        done = all(
-            [
-                poll_exit_response.done
-                for poll_exit_response in poll_exit_responses
-                if poll_exit_response
-            ]
-        )
-        if done:
-            printer.progress_close()
-
-    @staticmethod
-    def _footer_sync_info(
-        poll_exit_response: Optional[PollExitResponse] = None,
-        quiet: Optional[bool] = None,
-        *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
-    ) -> None:
-        if settings.silent:
-            return
-
-        if settings._offline:
-            printer.display(
-                [
-                    "You can sync this run to the cloud by running:",
-                    printer.code(f"wandb sync {settings.sync_dir}"),
-                ],
-                off=(quiet or settings.quiet),
+        if settings.project_url:
+            info.append(
+                f"{printer.emoji('star')} View project at: {printer.link(settings.project_url)}"
             )
-        else:
-            info = []
-            if settings.run_name and settings.run_url:
-                info.append(
-                    f"{printer.emoji('rocket')} View run {printer.name(settings.run_name)} at: {printer.link(settings.run_url)}"
-                )
-            if settings.project_url:
-                info.append(
-                    f"{printer.emoji('star')} View project at: {printer.link(settings.project_url)}"
-                )
-            if poll_exit_response and poll_exit_response.file_counts:
-                logger.info("logging synced files")
-                file_counts = poll_exit_response.file_counts
-                info.append(
-                    f"Synced {file_counts.wandb_count} W&B file(s), {file_counts.media_count} media file(s), "
-                    f"{file_counts.artifact_count} artifact file(s) and {file_counts.other_count} other file(s)",
-                )
-            printer.display(info)
+        if poll_exit_response and poll_exit_response.file_counts:
+            logger.info("logging synced files")
+            file_counts = poll_exit_response.file_counts
+            info.append(
+                f"Synced {file_counts.wandb_count} W&B file(s), {file_counts.media_count} media file(s), "
+                f"{file_counts.artifact_count} artifact file(s) and {file_counts.other_count} other file(s)",
+            )
+        printer.display(info)
 
     @staticmethod
     def _footer_log_dir_info(
-        quiet: Optional[bool] = None,
+        quiet: bool | None = None,
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         if (quiet or settings.quiet) or settings.silent:
             return
@@ -4025,12 +3958,12 @@ class Run:
 
     @staticmethod
     def _footer_history_summary_info(
-        history: Optional["SampledHistoryResponse"] = None,
-        summary: Optional["GetSummaryResponse"] = None,
-        quiet: Optional[bool] = None,
+        history: SampledHistoryResponse | None = None,
+        summary: GetSummaryResponse | None = None,
+        quiet: bool | None = None,
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         if (quiet or settings.quiet) or settings.silent:
             return
@@ -4096,11 +4029,11 @@ class Run:
 
     @staticmethod
     def _footer_internal_messages(
-        internal_messages_response: Optional["InternalMessagesResponse"] = None,
-        quiet: Optional[bool] = None,
+        internal_messages_response: InternalMessagesResponse | None = None,
+        quiet: bool | None = None,
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         if (quiet or settings.quiet) or settings.silent:
             return
@@ -4114,9 +4047,9 @@ class Run:
     @staticmethod
     def _footer_notify_wandb_core(
         *,
-        quiet: Optional[bool] = None,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        quiet: bool | None = None,
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         """Prints a message advertising the upcoming core release."""
         if quiet or not settings._require_legacy_service:
@@ -4131,11 +4064,11 @@ class Run:
 
     @staticmethod
     def _footer_reporter_warn_err(
-        reporter: Optional[Reporter] = None,
-        quiet: Optional[bool] = None,
+        reporter: Reporter | None = None,
+        quiet: bool | None = None,
         *,
-        settings: "Settings",
-        printer: Union["PrinterTerm", "PrinterJupyter"],
+        settings: Settings,
+        printer: printer.Printer,
     ) -> None:
         if (quiet or settings.quiet) or settings.silent:
             return
@@ -4161,10 +4094,10 @@ class Run:
 # We define this outside of the run context to support restoring before init
 def restore(
     name: str,
-    run_path: Optional[str] = None,
+    run_path: str | None = None,
     replace: bool = False,
-    root: Optional[str] = None,
-) -> Union[None, TextIO]:
+    root: str | None = None,
+) -> None | TextIO:
     """Download the specified file from cloud storage.
 
     File is placed into the current directory or run directory.
@@ -4222,7 +4155,7 @@ except AttributeError:
     pass
 
 
-def finish(exit_code: Optional[int] = None, quiet: Optional[bool] = None) -> None:
+def finish(exit_code: int | None = None, quiet: bool | None = None) -> None:
     """Mark a run as finished, and finish uploading all data.
 
     This is used when creating multiple runs in the same process.