wandb 0.19.1__py3-none-win32.whl → 0.19.2__py3-none-win32.whl

wandb/sdk/wandb_run.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import _thread as thread
 import atexit
 import functools
 import glob
@@ -37,6 +36,7 @@ from wandb.errors.links import url_registry
 from wandb.integration.torch import wandb_torch
 from wandb.plot import CustomChart, Visualize
 from wandb.proto.wandb_internal_pb2 import (
+    MetadataRequest,
     MetricRecord,
     PollExitResponse,
     Result,
@@ -73,6 +73,7 @@ from .lib import (
     deprecate,
     filenames,
     filesystem,
+    interrupt,
     ipython,
     module,
     printer,
@@ -84,6 +85,7 @@ from .lib import (
 from .lib.exit_hooks import ExitHooks
 from .lib.mailbox import MailboxError, MailboxHandle, MailboxProbe, MailboxProgress
 from .wandb_alerts import AlertLevel
+from .wandb_metadata import Metadata
 from .wandb_settings import Settings
 from .wandb_setup import _WandbSetup
 
@@ -287,7 +289,7 @@ class RunStatusChecker:
                 # TODO(frz): This check is required
                 # until WB-3606 is resolved on server side.
                 if not wandb.agents.pyagent.is_running():  # type: ignore
-                    thread.interrupt_main()
+                    interrupt.interrupt_main()
                     return
 
         try:
@@ -595,15 +597,17 @@ class Run:
         self._config._set_artifact_callback(self._config_artifact_callback)
         self._config._set_settings(self._settings)
 
-        # todo: perhaps this should be a property that is a noop on a finished run
+        # TODO: perhaps this should be a property that is a noop on a finished run
         self.summary = wandb_summary.Summary(
             self._summary_get_current_summary_callback,
         )
         self.summary._set_update_callback(self._summary_update_callback)
 
+        self.__metadata: Metadata | None = None
+
         self._step = 0
         self._starting_step = 0
-        # todo: eventually would be nice to make this configurable using self._settings._start_time
+        # 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()
@@ -1359,32 +1363,68 @@ class Run:
         files: FilesDict = dict(files=[(GlobStr(glob.escape(fname)), "now")])
         self._backend.interface.publish_files(files)
 
-    def _serialize_custom_charts(self, data: dict[str, Any]) -> dict[str, Any]:
-        if not data:
-            return data
+    def _pop_all_charts(
+        self,
+        data: dict[str, Any],
+        key_prefix: str | None = None,
+    ) -> dict[str, Any]:
+        """Pops all charts from a dictionary including nested charts.
 
-        chart_keys = set()
+        This function will return a mapping of the charts and a dot-separated
+        key for each chart. Indicating the path to the chart in the data dictionary.
+        """
+        keys_to_remove = set()
+        charts: dict[str, Any] = {}
         for k, v in data.items():
+            key = f"{key_prefix}.{k}" if key_prefix else k
             if isinstance(v, Visualize):
-                data[k] = v.table
-                v.set_key(k)
-                self._config_callback(
-                    val=v.spec.config_value,
-                    key=v.spec.config_key,
-                )
+                keys_to_remove.add(k)
+                charts[key] = v
             elif isinstance(v, CustomChart):
-                chart_keys.add(k)
-                v.set_key(k)
-                self._config_callback(
-                    key=v.spec.config_key,
-                    val=v.spec.config_value,
-                )
+                keys_to_remove.add(k)
+                charts[key] = v
+            elif isinstance(v, dict):
+                nested_charts = self._pop_all_charts(v, key)
+                charts.update(nested_charts)
+
+        for k in keys_to_remove:
+            data.pop(k)
+
+        return charts
+
+    def _serialize_custom_charts(
+        self,
+        data: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Process and replace chart objects with their underlying table values.
+
+        This processes the chart objects passed to `run.log()`, replacing their entries
+        in the given dictionary (which is saved to the run's history) and adding them
+        to the run's config.
+
+        Args:
+            data: Dictionary containing data that may include plot objects
+                Plot objects can be nested in dictionaries, which will be processed recursively.
+
+        Returns:
+            The processed dictionary with custom charts transformed into tables.
+        """
+        if not data:
+            return data
+
+        charts = self._pop_all_charts(data)
+        for k, v in charts.items():
+            v.set_key(k)
+            self._config_callback(
+                val=v.spec.config_value,
+                key=v.spec.config_key,
+            )
 
-        for k in chart_keys:
-            # remove the chart key from the row
-            v = data.pop(k)
             if isinstance(v, CustomChart):
                 data[v.spec.table_key] = v.table
+            elif isinstance(v, Visualize):
+                data[k] = v.table
+
         return data
 
     def _partial_history_callback(
@@ -2133,8 +2173,9 @@ class Run:
             # Inform the service that we're done sending messages for this run.
             #
             # TODO: Why not do this in _atexit_cleanup()?
-            service = self._wl and self._wl.service
-            if service and self._settings.run_id:
+            if self._settings.run_id:
+                assert self._wl
+                service = self._wl.assert_service()
                 service.inform_finish(run_id=self._settings.run_id)
 
         finally:
@@ -2313,7 +2354,7 @@ class Run:
             self._err_redir = err_redir
             logger.info("Redirects installed.")
         except Exception as e:
-            print(e)
+            wandb.termwarn(f"Failed to redirect: {e}")
             logger.error("Failed to redirect.", exc_info=e)
         return
 
@@ -2374,8 +2415,7 @@ class Run:
         logger.info("atexit reg")
         self._hooks = ExitHooks()
 
-        service = self._wl and self._wl.service
-        if not service:
+        if self.settings.x_disable_service:
             self._hooks.hook()
             # NB: manager will perform atexit hook like behavior for outstanding runs
             atexit.register(lambda: self._atexit_cleanup())
@@ -2388,10 +2428,6 @@ class Run:
             self._output_writer.close()
             self._output_writer = None
 
-    def _on_init(self) -> None:
-        if self._settings._offline:
-            return
-
     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)
@@ -3231,7 +3267,7 @@ class Run:
         use_after_commit: bool = False,
     ) -> Artifact:
         api = internal.Api()
-        if api.settings().get("anonymous") == "true":
+        if api.settings().get("anonymous") in ["allow", "must"]:
             wandb.termwarn(
                 "Artifacts logged anonymously cannot be claimed and expire after 7 days."
             )
@@ -3665,6 +3701,62 @@ class Run:
                 logger.error("Error getting system metrics: %s", e)
         return {}
 
+    @property
+    @_run_decorator._attach
+    @_run_decorator._noop_on_finish()
+    def _metadata(self) -> Metadata | None:
+        """The metadata associated with this run.
+
+        NOTE: Automatically collected metadata can be overridden by the user.
+        """
+        if not self._backend or not self._backend.interface:
+            return self.__metadata
+
+        # Initialize the metadata object if it doesn't exist.
+        if self.__metadata is None:
+            self.__metadata = Metadata()
+            self.__metadata._set_callback(self._metadata_callback)
+
+        handle = self._backend.interface.deliver_get_system_metadata()
+        result = handle.wait(timeout=1)
+
+        if not result:
+            logger.error("Error getting run metadata: no result")
+            return None
+
+        try:
+            response = result.response.get_system_metadata_response
+
+            # Temporarily disable the callback to prevent triggering
+            # an update call to wandb-core with the callback.
+            with self.__metadata.disable_callback():
+                # Values stored in the metadata object take precedence.
+                self.__metadata.update_from_proto(response.metadata, skip_existing=True)
+
+            return self.__metadata
+        except Exception as e:
+            logger.error("Error getting run metadata: %s", e)
+
+        return None
+
+    @_run_decorator._noop_on_finish()
+    @_run_decorator._attach
+    def _metadata_callback(
+        self,
+        metadata: MetadataRequest,
+    ) -> None:
+        """Callback to publish Metadata to wandb-core upon user updates."""
+        # ignore updates if the attached to another run
+        if self._is_attached:
+            wandb.termwarn(
+                "Metadata updates are ignored when attached to another run.",
+                repeat=False,
+            )
+            return
+
+        if self._backend and self._backend.interface:
+            self._backend.interface.publish_metadata(metadata)
+
     # ------------------------------------------------------------------------------
     # HEADER
     # ------------------------------------------------------------------------------
@@ -3772,8 +3864,8 @@ class Run:
             f'{printer.emoji("rocket")} View run at {printer.link(run_url)}',
         )
 
-        # TODO(settings) use `wandb_settings` (if self.settings.anonymous == "true":)
-        if run_name and Api().api.settings().get("anonymous") == "true":
+        # TODO(settings) use `wandb_settings` (if self.settings.anonymous in ["allow", "must"]:)
+        if run_name and Api().api.settings().get("anonymous") in ["allow", "must"]:
             printer.display(
                 (
                     "Do NOT share these links with anyone."

wandb/sdk/wandb_settings.py

@@ -349,7 +349,7 @@ class Settings(BaseModel, validate_assignment=True):
     @model_validator(mode="before")
     @classmethod
     def catch_private_settings(cls, values):
-        """Check if a private field is provided and assign to the corrsponding public one.
+        """Check if a private field is provided and assign to the corresponding public one.
 
         This is a compatibility layer to handle previous versions of the settings.
         """
@@ -961,7 +961,7 @@ class Settings(BaseModel, validate_assignment=True):
     # The Settings class does not track the source of the settings,
     # so it is up to the developer to ensure that the settings are applied
     # in the correct order. Most of the updates are done in
-    # wandb/sdk/wandb_setup.py::_WandbSetup__WandbSetup._settings_setup.
+    # wandb/sdk/wandb_setup.py::_WandbSetup._settings_setup.
 
     def update_from_system_config_file(self):
         """Update settings from the system config file."""
@@ -1063,7 +1063,8 @@ class Settings(BaseModel, validate_assignment=True):
         )
         self.x_executable = _executable
 
-        self.docker = env.get_docker(util.image_id_from_k8s())
+        if self.docker is None:
+            self.docker = env.get_docker(util.image_id_from_k8s())
 
         # proceed if not in CLI mode
         if self.x_cli_only_mode:
@@ -1176,38 +1177,6 @@ class Settings(BaseModel, validate_assignment=True):
             with open(self.resume_fname, "w") as f:
                 f.write(json.dumps({"run_id": self.run_id}))
 
-    def handle_sweep_logic(self):
-        """Update settings based on sweep context.
-
-        When running a sweep, the project, entity, and run_id are handled externally,
-        and should be ignored if they are set.
-        """
-        if self.sweep_id is None:
-            return
-
-        for key in ("project", "entity", "run_id"):
-            value = getattr(self, key)
-            if value is not None:
-                wandb.termwarn(f"Ignoring {key} {value!r} when running a sweep.")
-                setattr(self, key, None)
-
-    def handle_launch_logic(self):
-        """Update settings based on launch context.
-
-        When running in a launch context, the project, entity, and run_id are handled
-        externally, and should be ignored if they are set.
-        """
-        if not self.launch:
-            return
-
-        for key in ("project", "entity", "run_id"):
-            value = getattr(self, key)
-            if value is not None:
-                wandb.termwarn(
-                    f"Ignoring {key} {value!r} when running from wandb launch context."
-                )
-                setattr(self, key, None)
-
     @staticmethod
     def validate_url(url: str) -> None:
         """Validate a URL string."""
@@ -1293,7 +1262,7 @@ class Settings(BaseModel, validate_assignment=True):
     def _get_url_query_string(self) -> str:
         """Construct the query string for project, run, and sweep URLs."""
         # TODO: remove dependency on Api()
-        if Api().settings().get("anonymous") != "true":
+        if Api().settings().get("anonymous") not in ["allow", "must"]:
             return ""
 
         api_key = apikey.api_key(settings=self)

wandb/sdk/wandb_setup.py

@@ -20,6 +20,7 @@ import threading
 from typing import TYPE_CHECKING, Any, Union
 
 import wandb
+import wandb.integration.sagemaker as sagemaker
 from wandb.sdk.lib import import_hooks
 
 from . import wandb_settings
@@ -61,29 +62,19 @@ class _EarlyLogger:
     def log(self, level: str, msg: str, *args: Any, **kwargs: Any) -> None:
         self._log.append((level, msg, args, kwargs))
 
-    def _flush(self) -> None:
-        assert self is not logger
-        assert logger is not None
+    def _flush(self, new_logger: Logger) -> None:
+        assert self is not new_logger
         for level, msg, args, kwargs in self._log:
-            logger.log(level, msg, *args, **kwargs)
+            new_logger.log(level, msg, *args, **kwargs)
         for msg, args, kwargs in self._exception:
-            logger.exception(msg, *args, **kwargs)
+            new_logger.exception(msg, *args, **kwargs)
 
 
 Logger = Union[logging.Logger, _EarlyLogger]
 
-# logger will be configured to be either a standard logger instance or _EarlyLogger
-logger: Logger | None = None
 
-
-def _set_logger(log_object: Logger) -> None:
-    """Configure module logger."""
-    global logger
-    logger = log_object
-
-
-class _WandbSetup__WandbSetup:  # noqa: N801
-    """Inner class of _WandbSetup."""
+class _WandbSetup:
+    """W&B library singleton."""
 
     def __init__(
         self,
@@ -104,48 +95,52 @@ class _WandbSetup__WandbSetup:  # noqa: N801
 
         # TODO(jhr): defer strict checks until settings are fully initialized
         #            and logging is ready
-        self._early_logger = _EarlyLogger()
-        _set_logger(self._early_logger)
+        self._logger: Logger = _EarlyLogger()
 
-        self._settings = self._settings_setup(settings, self._early_logger)
+        self._settings = self._settings_setup(settings)
 
-        wandb.termsetup(self._settings, logger)
+        wandb.termsetup(self._settings, None)
 
         self._check()
         self._setup()
 
     def _settings_setup(
         self,
-        settings: Settings | None = None,
-        early_logger: _EarlyLogger | None = None,
+        settings: Settings | None,
     ) -> wandb_settings.Settings:
         s = wandb_settings.Settings()
 
         # the pid of the process to monitor for system stats
         pid = os.getpid()
-        if early_logger:
-            early_logger.info(f"Current SDK version is {wandb.__version__}")
-            early_logger.info(f"Configure stats pid to {pid}")
+        self._logger.info(f"Current SDK version is {wandb.__version__}")
+        self._logger.info(f"Configure stats pid to {pid}")
         s.x_stats_pid = pid
 
         # load settings from the system config
-        if s.settings_system and early_logger:
-            early_logger.info(f"Loading settings from {s.settings_system}")
+        if s.settings_system:
+            self._logger.info(f"Loading settings from {s.settings_system}")
         s.update_from_system_config_file()
 
         # load settings from the workspace config
-        if s.settings_workspace and early_logger:
-            early_logger.info(f"Loading settings from {s.settings_workspace}")
+        if s.settings_workspace:
+            self._logger.info(f"Loading settings from {s.settings_workspace}")
         s.update_from_workspace_config_file()
 
         # load settings from the environment variables
-        if early_logger:
-            early_logger.info("Loading settings from environment variables")
+        self._logger.info("Loading settings from environment variables")
         s.update_from_env_vars(self._environ)
 
         # infer settings from the system environment
         s.update_from_system_environment()
 
+        # load SageMaker settings
+        check_sagemaker_env = not s.sagemaker_disable
+        if settings and settings.sagemaker_disable:
+            check_sagemaker_env = False
+        if check_sagemaker_env and sagemaker.is_using_sagemaker():
+            self._logger.info("Loading SageMaker settings")
+            sagemaker.set_global_settings(s)
+
         # load settings from the passed init/setup settings
         if settings:
             s.update_from_settings(settings)
@@ -165,13 +160,15 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             self._settings.update_from_dict(user_settings)
 
     def _early_logger_flush(self, new_logger: Logger) -> None:
-        if not self._early_logger:
+        if self._logger is new_logger:
             return
-        _set_logger(new_logger)
-        self._early_logger._flush()
 
-    def _get_logger(self) -> Logger | None:
-        return logger
+        if isinstance(self._logger, _EarlyLogger):
+            self._logger._flush(new_logger)
+        self._logger = new_logger
+
+    def _get_logger(self) -> Logger:
+        return self._logger
 
     @property
     def settings(self) -> wandb_settings.Settings:
@@ -236,16 +233,11 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             if threading.current_thread() is not threading.main_thread():
                 pass
         elif threading.current_thread().name != "MainThread":
-            print("bad thread2", threading.current_thread().name)
+            wandb.termwarn(f"bad thread2: {threading.current_thread().name}")
         if getattr(sys, "frozen", False):
-            print("frozen, could be trouble")
+            wandb.termwarn("frozen, could be trouble")
 
     def _setup(self) -> None:
-        if not self._settings._noop and not self._settings.x_disable_service:
-            from wandb.sdk.lib import service_connection
-
-            self._connection = service_connection.connect_to_service(self._settings)
-
         sweep_path = self._settings.sweep_param_path
         if sweep_path:
             self._sweep_config = config_util.dict_from_config_file(
@@ -278,53 +270,61 @@ class _WandbSetup__WandbSetup:  # noqa: N801
         if internal_exit_code != 0:
             sys.exit(internal_exit_code)
 
-    @property
-    def service(self) -> ServiceConnection | None:
-        """Returns a connection to the service process, if it exists."""
+    def ensure_service(self) -> ServiceConnection:
+        """Returns a connection to the service process creating it if needed."""
+        if self._connection:
+            return self._connection
+
+        from wandb.sdk.lib import service_connection
+
+        self._connection = service_connection.connect_to_service(self._settings)
         return self._connection
 
+    def assert_service(self) -> ServiceConnection:
+        """Returns a connection to the service process, asserting it exists.
 
-class _WandbSetup:
-    """Wandb singleton class.
+        Unlike ensure_service(), this will not start up a service process
+        if it didn't already exist.
+        """
+        if not self._connection:
+            raise AssertionError("Expected service process to exist.")
 
-    Note: This is a process local singleton.
-    (Forked processes will get a new copy of the object)
-    """
+        return self._connection
 
-    _instance: _WandbSetup__WandbSetup | None = None
 
-    def __init__(self, settings: Settings | None = None) -> None:
-        pid = os.getpid()
-        if _WandbSetup._instance and _WandbSetup._instance._pid == pid:
-            _WandbSetup._instance._update(settings=settings)
-            return
-        _WandbSetup._instance = _WandbSetup__WandbSetup(settings=settings, pid=pid)
+_singleton: _WandbSetup | None = None
+"""The W&B library singleton, or None if not yet set up.
 
-    @property
-    def service(self) -> ServiceConnection | None:
-        """Returns a connection to the service process, if it exists."""
-        if not self._instance:
-            return None
-        return self._instance.service
+The value is invalid and must not be used if `os.getpid() != _singleton._pid`.
+"""
 
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._instance, name)
 
+def singleton() -> _WandbSetup | None:
+    """Returns the W&B singleton if it exists for the current process.
 
-def _setup(
-    settings: Settings | None = None,
-    _reset: bool = False,
-) -> _WandbSetup | None:
-    """Set up library context."""
-    if _reset:
-        teardown()
+    Unlike setup(), this does not create the singleton if it doesn't exist.
+    """
+    if _singleton and _singleton._pid == os.getpid():
+        return _singleton
+    else:
         return None
 
-    wl = _WandbSetup(settings=settings)
-    return wl
 
+def _setup(settings: Settings | None = None) -> _WandbSetup:
+    """Set up library context."""
+    global _singleton
+
+    pid = os.getpid()
 
-def setup(settings: Settings | None = None) -> _WandbSetup | None:
+    if _singleton and _singleton._pid == pid:
+        _singleton._update(settings=settings)
+        return _singleton
+    else:
+        _singleton = _WandbSetup(settings=settings, pid=pid)
+        return _singleton
+
+
+def setup(settings: Settings | None = None) -> _WandbSetup:
     """Prepares W&B for use in the current process and its children.
 
     You can usually ignore this as it is implicitly called by `wandb.init()`.
@@ -380,8 +380,7 @@ def setup(settings: Settings | None = None) -> _WandbSetup | None:
             wandb.teardown()
         ```
     """
-    ret = _setup(settings=settings)
-    return ret
+    return _setup(settings=settings)
 
 
 def teardown(exit_code: int | None = None) -> None:
@@ -395,8 +394,10 @@ def teardown(exit_code: int | None = None) -> None:
     in an `atexit` hook, but this is not reliable in certain setups
     such as when using Python's `multiprocessing` module.
     """
-    setup_instance = _WandbSetup._instance
-    _WandbSetup._instance = None
+    global _singleton
+
+    orig_singleton = _singleton
+    _singleton = None
 
-    if setup_instance:
-        setup_instance._teardown(exit_code=exit_code)
+    if orig_singleton:
+        orig_singleton._teardown(exit_code=exit_code)

wandb/sdk/wandb_sweep.py

@@ -85,10 +85,10 @@ def sweep(
     api = InternalApi()
     sweep_id, warnings = api.upsert_sweep(sweep, prior_runs=prior_runs)
     handle_sweep_config_violations(warnings)
-    print("Create sweep with ID:", sweep_id)
+    print("Create sweep with ID:", sweep_id)  # noqa: T201
     sweep_url = _get_sweep_url(api, sweep_id)
     if sweep_url:
-        print("Sweep URL:", sweep_url)
+        print("Sweep URL:", sweep_url)  # noqa: T201
     return sweep_id