wandb 0.18.6__py3-none-macosx_11_0_arm64.whl → 0.19.0__py3-none-macosx_11_0_arm64.whl

wandb/sdk/wandb_run.py

@@ -19,18 +19,15 @@ from collections.abc import Mapping
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from enum import IntEnum
+from functools import reduce
 from types import TracebackType
-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
+from typing import TYPE_CHECKING, Any, Callable, Literal, NamedTuple, Sequence, TextIO
 
 import requests
 
 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
@@ -39,7 +36,7 @@ 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, plot_table
+from wandb.plot import CustomChart, Visualize
 from wandb.proto.wandb_internal_pb2 import (
     MetricRecord,
     PollExitResponse,
@@ -89,23 +86,18 @@ from .lib.exit_hooks import ExitHooks
 from .lib.gitlib import GitRepo
 from .lib.mailbox import MailboxError, MailboxHandle, MailboxProbe, MailboxProgress
 from .lib.proto_util import message_to_dict
-from .lib.reporting import Reporter
 from .wandb_alerts import AlertLevel
 from .wandb_settings import Settings
 from .wandb_setup import _WandbSetup
 
 if TYPE_CHECKING:
-    if sys.version_info >= (3, 8):
-        from typing import TypedDict
-    else:
-        from typing_extensions import TypedDict
+    from typing 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,
@@ -440,7 +432,7 @@ class _run_decorator:  # noqa: N801
                     # - 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"]:
+                    if settings and settings.strict:
                         wandb.termerror(message, repeat=False)
                         raise UnsupportedError(
                             f"`{func.__name__}` does not support multiprocessing"
@@ -539,7 +531,6 @@ class Run:
     _sweep_id: str | None
 
     _run_obj: RunRecord | None
-    # Use string literal annotation because of type reference loop
     _backend: wandb.sdk.backend.backend.Backend | None
     _internal_run_interface: wandb.sdk.interface.interface_queue.InterfaceQueue | None
     _wl: _WandbSetup | None
@@ -549,7 +540,6 @@ class Run:
     _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: ExitHooks | None
@@ -634,7 +624,6 @@ class Run:
 
         self._printer = printer.new_printer()
         self._wl = None
-        self._reporter: Reporter | None = None
 
         self._entity = None
         self._project = None
@@ -657,7 +646,6 @@ class Run:
         self._stderr_slave_fd = None
         self._exit_code = None
         self._exit_result = None
-        self._quiet = self._settings.quiet
 
         self._output_writer = None
         self._used_artifact_slots: dict[str, str] = {}
@@ -751,7 +739,7 @@ class Run:
         self._attach_pid = os.getpid()
 
         # for now, use runid as attach id, this could/should be versioned in the future
-        if not self._settings._disable_service:
+        if not self._settings.x_disable_service:
             self._attach_id = self._settings.run_id
 
     def _set_iface_pid(self, iface_pid: int) -> None:
@@ -896,7 +884,7 @@ class Run:
     def __getstate__(self) -> Any:
         """Return run state as a custom pickle."""
         # We only pickle in service mode
-        if not self._settings or self._settings._disable_service:
+        if not self._settings or self._settings.x_disable_service:
             return
 
         _attach_id = self._attach_id
@@ -933,9 +921,7 @@ class Run:
     @_run_decorator._attach
     def settings(self) -> Settings:
         """A frozen copy of run's Settings object."""
-        cp = self._settings.copy()
-        cp.freeze()
-        return cp
+        return self._settings.model_copy(deep=True)
 
     @property
     @_run_decorator._attach
@@ -1193,11 +1179,11 @@ class Run:
                 notebook_name = None
                 if self.settings.notebook_name:
                     notebook_name = self.settings.notebook_name
-                elif self.settings._jupyter_path:
-                    if self.settings._jupyter_path.startswith("fileId="):
-                        notebook_name = self.settings._jupyter_name
+                elif self.settings.x_jupyter_path:
+                    if self.settings.x_jupyter_path.startswith("fileId="):
+                        notebook_name = self.settings.x_jupyter_name
                     else:
-                        notebook_name = self.settings._jupyter_path
+                        notebook_name = self.settings.x_jupyter_path
                 name_string = f"{self._project}-{notebook_name}"
             else:
                 name_string = f"{self._project}-{self._settings.program_relpath}"
@@ -1469,12 +1455,14 @@ 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]:
-        # TODO(jhr): move visualize hack somewhere else
+    def _serialize_custom_charts(self, data: dict[str, Any]) -> dict[str, Any]:
+        if not data:
+            return data
+
         chart_keys = set()
-        for k, v in row.items():
+        for k, v in data.items():
             if isinstance(v, Visualize):
-                row[k] = v.table
+                data[k] = v.table
                 v.set_key(k)
                 self._config_callback(
                     val=v.spec.config_value,
@@ -1490,31 +1478,33 @@ class Run:
 
         for k in chart_keys:
             # remove the chart key from the row
-            v = row.pop(k)
+            v = data.pop(k)
             if isinstance(v, CustomChart):
-                row[v.spec.table_key] = v.table
-        return row
+                data[v.spec.table_key] = v.table
+        return data
 
     def _partial_history_callback(
         self,
-        row: dict[str, Any],
+        data: dict[str, Any],
         step: int | None = None,
         commit: bool | None = None,
     ) -> None:
-        row = row.copy()
-        if row:
-            row = self._visualization_hack(row)
+        if not (self._backend and self._backend.interface):
+            return
 
-        if self._backend and self._backend.interface:
-            not_using_tensorboard = len(wandb.patched["tensorboard"]) == 0
-
-            self._backend.interface.publish_partial_history(
-                row,
-                user_step=self._step,
-                step=step,
-                flush=commit,
-                publish_step=not_using_tensorboard,
-            )
+        data = data.copy()  # avoid modifying the original data
+
+        # Serialize custom charts before publishing
+        data = self._serialize_custom_charts(data)
+
+        not_using_tensorboard = len(wandb.patched["tensorboard"]) == 0
+        self._backend.interface.publish_partial_history(
+            data,
+            user_step=self._step,
+            step=step,
+            flush=commit,
+            publish_step=not_using_tensorboard,
+        )
 
     def _console_callback(self, name: str, data: str) -> None:
         # logger.info("console callback: %s, %s", name, data)
@@ -1555,9 +1545,6 @@ class Run:
     ) -> 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:
         self._teardown_hooks = hooks
 
@@ -1587,8 +1574,31 @@ class Run:
         self._step = self._get_starting_step()
 
         # update settings from run_obj
-        self._settings._apply_run_start(message_to_dict(self._run_obj))
-        self._update_settings(self._settings)
+        run_start_settings = message_to_dict(self._run_obj)
+        param_map = {
+            "run_id": "run_id",
+            "entity": "entity",
+            "project": "project",
+            "run_group": "run_group",
+            "job_type": "run_job_type",
+            "display_name": "run_name",
+            "notes": "run_notes",
+            "tags": "run_tags",
+            "sweep_id": "sweep_id",
+            "host": "host",
+            "resumed": "resumed",
+            "git.remote_url": "git_remote_url",
+            "git.commit": "git_commit",
+        }
+        run_settings = {
+            name: reduce(lambda d, k: d.get(k, {}), attr.split("."), run_start_settings)
+            for attr, name in param_map.items()
+        }
+        run_settings = {key: value for key, value in run_settings.items() if value}
+
+        if run_settings:
+            self._settings.update_from_dict(run_settings)
+            self._update_settings(self._settings)
 
         wandb._sentry.configure_scope(
             process_context="user",
@@ -2032,7 +2042,7 @@ class Run:
         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.
+        # but we support down to Python 3.8.
         if not str(glob_path).startswith(str(base_path)):
             raise ValueError("Glob may not walk above the base path")
 
@@ -2076,12 +2086,7 @@ class Run:
             target_path.parent.mkdir(parents=True, exist_ok=True)
 
             # Delete the symlink if it exists.
-            try:
-                target_path.unlink()
-            except FileNotFoundError:
-                # In Python 3.8, we would pass missing_ok=True, but as of now
-                # we support down to Python 3.7.
-                pass
+            target_path.unlink(missing_ok=True)
 
             target_path.symlink_to(source_path)
 
@@ -2126,30 +2131,45 @@ class Run:
 
     @_run_decorator._noop
     @_run_decorator._attach
-    def finish(self, exit_code: int | None = None, quiet: bool | None = None) -> None:
-        """Mark a run as finished, and finish uploading all data.
+    def finish(
+        self,
+        exit_code: int | None = None,
+        quiet: bool | None = None,
+    ) -> None:
+        """Finish a run and upload any remaining data.
+
+        Marks the completion of a W&B run and ensures all data is synced to the server.
+        The run's final state is determined by its exit conditions and sync status.
 
-        This is used when creating multiple runs in the same process. We automatically
-        call this method when your script exits or if you use the run context manager.
+        Run States:
+        - Running: Active run that is logging data and/or sending heartbeats.
+        - Crashed: Run that stopped sending heartbeats unexpectedly.
+        - Finished: Run completed successfully (`exit_code=0`) with all data synced.
+        - Failed: Run completed with errors (`exit_code!=0`).
 
         Args:
-            exit_code: Set to something other than 0 to mark a run as failed
-            quiet: Set to true to minimize log output
+            exit_code: Integer indicating the run's exit status. Use 0 for success,
+                any other value marks the run as failed.
+            quiet: Deprecated. Configure logging verbosity using `wandb.Settings(quiet=...)`.
         """
-        return self._finish(exit_code, quiet)
+        if quiet is not None:
+            deprecate.deprecate(
+                field_name=deprecate.Deprecated.run__finish_quiet,
+                warning_message=(
+                    "The `quiet` argument to `wandb.run.finish()` is deprecated, "
+                    "use `wandb.Settings(quiet=...)` to set this instead."
+                ),
+            )
+        return self._finish(exit_code)
 
     def _finish(
         self,
         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:
             tel.feature.finish = True
 
-        if quiet is not None:
-            self._quiet = quiet
-
         # Pop this run (hopefully) from the run stack, to support the "reinit"
         # functionality of wandb.init().
         #
@@ -2183,7 +2203,7 @@ class Run:
             #
             # TODO: Why not do this in _atexit_cleanup()?
             service = self._wl and self._wl.service
-            if service:
+            if service and self._run_id:
                 service.inform_finish(run_id=self._run_id)
 
         finally:
@@ -2228,31 +2248,6 @@ class Run:
             sync_time=sync_time,
         )
 
-    @staticmethod
-    def plot_table(
-        vega_spec_name: str,
-        data_table: Table,
-        fields: dict[str, Any],
-        string_fields: dict[str, Any] | None = None,
-        split_table: bool = False,
-    ) -> CustomChart:
-        """Create a custom plot on a table.
-
-        Args:
-            vega_spec_name: the name of the spec for the plot
-            data_table: a wandb.Table object containing the data to
-                be used on the visualization
-            fields: a dict mapping from table keys to fields that the custom
-                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 plot_table(
-            vega_spec_name, data_table, fields, string_fields or {}, split_table
-        )
-
     def _add_panel(
         self, visualize_key: str, panel_type: str, panel_config: dict
     ) -> None:
@@ -2272,7 +2267,6 @@ class Run:
             use_artifact=self.use_artifact,
             log_artifact=self.log_artifact,
             define_metric=self.define_metric,
-            plot_table=self.plot_table,
             alert=self.alert,
             watch=self.watch,
             unwatch=self.unwatch,
@@ -2292,7 +2286,7 @@ class Run:
             console = self._settings.console
         # only use raw for service to minimize potential changes
         if console == "wrap":
-            if not self._settings._disable_service:
+            if not self._settings.x_disable_service:
                 console = "wrap_raw"
             else:
                 console = "wrap_emu"
@@ -2441,8 +2435,6 @@ class Run:
             final_summary=self._final_summary,
             poll_exit_response=self._poll_exit_response,
             internal_messages_response=self._internal_messages_response,
-            reporter=self._reporter,
-            quiet=self._quiet,
             settings=self._settings,
             printer=self._printer,
         )
@@ -2481,7 +2473,7 @@ class Run:
         if self._settings.save_code and self._settings.code_dir is not None:
             self.log_code(self._settings.code_dir)
 
-        if self._settings._save_requirements:
+        if self._settings.x_save_requirements:
             if self._backend and self._backend.interface:
                 from wandb.util import working_set
 
@@ -2525,6 +2517,8 @@ class Run:
 
         import_telemetry_set = telemetry.list_telemetry_imports()
         import_hook_fn = functools.partial(_telemetry_import_hook, self)
+        if not self._run_id:
+            return
         for module_name in import_telemetry_set:
             register_post_import_hook(
                 import_hook_fn,
@@ -2665,7 +2659,11 @@ class Run:
 
         assert self._backend and self._backend.interface
 
-        exit_handle = self._backend.interface.deliver_exit(self._exit_code)
+        if self._settings.x_update_finish_state:
+            exit_handle = self._backend.interface.deliver_exit(self._exit_code)
+        else:
+            exit_handle = self._backend.interface.deliver_finish_without_exit()
+
         exit_handle.add_probe(on_probe=self._on_probe_exit)
 
         with progress.progress_printer(
@@ -2717,7 +2715,8 @@ class Run:
         if self._run_status_checker:
             self._run_status_checker.join()
 
-        self._unregister_telemetry_import_hooks(self._run_id)
+        if self._run_id:
+            self._unregister_telemetry_import_hooks(self._run_id)
 
     @staticmethod
     def _unregister_telemetry_import_hooks(run_id: str) -> None:
@@ -2870,7 +2869,7 @@ class Run:
     def watch(
         self,
         models: torch.nn.Module | Sequence[torch.nn.Module],
-        criterion: torch.F | None = None,
+        criterion: torch.F | None = None,  # type: ignore
         log: Literal["gradients", "parameters", "all"] | None = "gradients",
         log_freq: int = 1000,
         idx: int | None = None,
@@ -3350,7 +3349,7 @@ class Run:
         return artifact
 
     def _public_api(self, overrides: dict[str, str] | None = None) -> PublicApi:
-        overrides = {"run": self._run_id}
+        overrides = {"run": self._run_id}  # type: ignore
         if not (self._settings._offline or self._run_obj is None):
             overrides["entity"] = self._run_obj.entity
             overrides["project"] = self._run_obj.project
@@ -3688,9 +3687,10 @@ class Run:
         Returns:
             A dictionary of system metrics.
         """
+        from wandb.proto import wandb_internal_pb2
 
         def pb_to_dict(
-            system_metrics_pb: wandb.proto.wandb_internal_pb2.GetSystemMetricsResponse,
+            system_metrics_pb: wandb_internal_pb2.GetSystemMetricsResponse,
         ) -> dict[str, list[tuple[datetime, float]]]:
             res = {}
 
@@ -3852,8 +3852,6 @@ class Run:
         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: printer.Printer,
@@ -3861,37 +3859,29 @@ class Run:
         Run._footer_history_summary_info(
             history=sampled_history,
             summary=final_summary,
-            quiet=quiet,
             settings=settings,
             printer=printer,
         )
 
         Run._footer_sync_info(
             poll_exit_response=poll_exit_response,
-            quiet=quiet,
             settings=settings,
             printer=printer,
         )
-        Run._footer_log_dir_info(quiet=quiet, settings=settings, printer=printer)
+        Run._footer_log_dir_info(settings=settings, printer=printer)
         Run._footer_notify_wandb_core(
-            quiet=quiet,
             settings=settings,
             printer=printer,
         )
         Run._footer_internal_messages(
             internal_messages_response=internal_messages_response,
-            quiet=quiet,
             settings=settings,
             printer=printer,
         )
-        Run._footer_reporter_warn_err(
-            reporter=reporter, quiet=quiet, settings=settings, printer=printer
-        )
 
     @staticmethod
     def _footer_sync_info(
         poll_exit_response: PollExitResponse | None = None,
-        quiet: bool | None = None,
         *,
         settings: Settings,
         printer: printer.Printer,
@@ -3900,7 +3890,7 @@ class Run:
             return
 
         if settings._offline:
-            if not quiet and not settings.quiet:
+            if not settings.quiet:
                 printer.display(
                     [
                         "You can sync this run to the cloud by running:",
@@ -3929,12 +3919,11 @@ class Run:
 
     @staticmethod
     def _footer_log_dir_info(
-        quiet: bool | None = None,
         *,
         settings: Settings,
         printer: printer.Printer,
     ) -> None:
-        if (quiet or settings.quiet) or settings.silent:
+        if settings.quiet or settings.silent:
             return
 
         log_dir = settings.log_user or settings.log_internal
@@ -3948,12 +3937,11 @@ class Run:
     def _footer_history_summary_info(
         history: SampledHistoryResponse | None = None,
         summary: GetSummaryResponse | None = None,
-        quiet: bool | None = None,
         *,
         settings: Settings,
         printer: printer.Printer,
     ) -> None:
-        if (quiet or settings.quiet) or settings.silent:
+        if settings.quiet or settings.silent:
             return
 
         panel = []
@@ -4018,12 +4006,11 @@ class Run:
     @staticmethod
     def _footer_internal_messages(
         internal_messages_response: InternalMessagesResponse | None = None,
-        quiet: bool | None = None,
         *,
         settings: Settings,
         printer: printer.Printer,
     ) -> None:
-        if (quiet or settings.quiet) or settings.silent:
+        if settings.quiet or settings.silent:
             return
 
         if not internal_messages_response:
@@ -4035,12 +4022,11 @@ class Run:
     @staticmethod
     def _footer_notify_wandb_core(
         *,
-        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:
+        if settings.quiet or not settings.x_require_legacy_service:
             return
 
         printer.display(
@@ -4050,34 +4036,6 @@ class Run:
             level="warn",
         )
 
-    @staticmethod
-    def _footer_reporter_warn_err(
-        reporter: Reporter | None = None,
-        quiet: bool | None = None,
-        *,
-        settings: Settings,
-        printer: printer.Printer,
-    ) -> None:
-        if (quiet or settings.quiet) or settings.silent:
-            return
-
-        if not reporter:
-            return
-
-        warning_lines = reporter.warning_lines
-        if warning_lines:
-            warnings = ["Warnings:"] + [f"{line}" for line in warning_lines]
-            if len(warning_lines) < reporter.warning_count:
-                warnings.append("More warnings...")
-            printer.display(warnings)
-
-        error_lines = reporter.error_lines
-        if error_lines:
-            errors = ["Errors:"] + [f"{line}" for line in error_lines]
-            if len(error_lines) < reporter.error_count:
-                errors.append("More errors...")
-            printer.display(errors)
-
 
 # We define this outside of the run context to support restoring before init
 def restore(
@@ -4143,15 +4101,25 @@ except AttributeError:
     pass
 
 
-def finish(exit_code: int | None = None, quiet: bool | None = None) -> None:
-    """Mark a run as finished, and finish uploading all data.
+def finish(
+    exit_code: int | None = None,
+    quiet: bool | None = None,
+) -> None:
+    """Finish a run and upload any remaining data.
+
+    Marks the completion of a W&B run and ensures all data is synced to the server.
+    The run's final state is determined by its exit conditions and sync status.
 
-    This is used when creating multiple runs in the same process.
-    We automatically call this method when your script exits.
+    Run States:
+    - Running: Active run that is logging data and/or sending heartbeats.
+    - Crashed: Run that stopped sending heartbeats unexpectedly.
+    - Finished: Run completed successfully (`exit_code=0`) with all data synced.
+    - Failed: Run completed with errors (`exit_code!=0`).
 
     Args:
-        exit_code: Set to something other than 0 to mark a run as failed
-        quiet: Set to true to minimize log output
+        exit_code: Integer indicating the run's exit status. Use 0 for success,
+            any other value marks the run as failed.
+        quiet: Deprecated. Configure logging verbosity using `wandb.Settings(quiet=...)`.
     """
     if wandb.run:
         wandb.run.finish(exit_code=exit_code, quiet=quiet)