wandb 0.17.0rc1__py3-none-macosx_11_0_arm64.whl → 0.17.1__py3-none-macosx_11_0_arm64.whl

wandb/sdk/wandb_login.py

@@ -6,7 +6,7 @@ This authenticates your machine to log data to your account.
 import enum
 import os
 import sys
-from typing import Dict, Optional, Tuple
+from typing import Optional, Tuple
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -112,11 +112,10 @@ class ApiKeyStatus(enum.Enum):
 
 class _WandbLogin:
     def __init__(self):
-        self.kwargs: Optional[Dict] = None
         self._settings: Optional[Settings] = None
         self._backend = None
-        self._silent = None
-        self._entity = None
+        self._silent: Optional[bool] = None
+        self._entity: Optional[str] = None
         self._wl = None
         self._key = None
         self._relogin = None
@@ -130,7 +129,8 @@ class _WandbLogin:
         host: Optional[str] = None,
         force: Optional[bool] = None,
         timeout: Optional[int] = None,
-    ):
+    ) -> None:
+        """Updates login-related settings on the global setup object."""
         self._relogin = relogin
 
         # built up login settings
@@ -152,19 +152,24 @@ class _WandbLogin:
         self._wl = wandb.setup(settings=login_settings)
         self._settings = self._wl.settings
 
-    def is_apikey_configured(self):
+    def is_apikey_configured(self) -> bool:
+        """Returns whether an API key is set or can be inferred."""
         return apikey.api_key(settings=self._settings) is not None
 
     def set_backend(self, backend):
         self._backend = backend
 
-    def set_silent(self, silent: bool):
+    def set_silent(self, silent: bool) -> None:
         self._silent = silent
 
-    def set_entity(self, entity: str):
+    def set_entity(self, entity: str) -> None:
         self._entity = entity
 
-    def login(self):
+    def login(self) -> bool:
+        """Returns whether the user is logged in (i.e. an API key exists).
+
+        If the user is logged in, this also prints an informational message.
+        """
         apikey_configured = self.is_apikey_configured()
         if self._settings.relogin or self._relogin:
             apikey_configured = False
@@ -172,11 +177,12 @@ class _WandbLogin:
             return False
 
         if not self._silent:
-            self.login_display()
+            self._print_logged_in_message()
 
         return apikey_configured
 
-    def login_display(self):
+    def _print_logged_in_message(self) -> None:
+        """Prints a message telling the user they are logged in."""
         username = self._wl._get_username()
 
         if username:
@@ -200,7 +206,8 @@ class _WandbLogin:
             repeat=False,
         )
 
-    def configure_api_key(self, key):
+    def configure_api_key(self, key: str) -> None:
+        """Saves the API key and updates the the global setup object."""
         if self._settings._notebook and not self._settings.silent:
             wandb.termwarn(
                 "If you're specifying your api key in code, ensure this "
@@ -213,8 +220,14 @@ class _WandbLogin:
         self._key = key
 
     def update_session(
-        self, key: Optional[str], status: ApiKeyStatus = ApiKeyStatus.VALID
+        self,
+        key: Optional[str],
+        status: ApiKeyStatus = ApiKeyStatus.VALID,
     ) -> None:
+        """Updates mode and API key settings on the global setup object.
+
+        If we're online, this also pulls in user settings from the server.
+        """
         _logger = wandb.setup()._get_logger()
         login_settings = dict()
         if status == ApiKeyStatus.OFFLINE:
@@ -252,7 +265,8 @@ class _WandbLogin:
                 return None, ApiKeyStatus.OFFLINE
             return key, ApiKeyStatus.VALID
 
-    def prompt_api_key(self):
+    def prompt_api_key(self) -> None:
+        """Updates the global API key by prompting the user."""
         key, status = self._prompt_api_key()
         if status == ApiKeyStatus.NOTTY:
             directive = (
@@ -265,14 +279,6 @@ class _WandbLogin:
         self.update_session(key, status=status)
         self._key = key
 
-    def propogate_login(self):
-        # TODO(jhr): figure out if this is really necessary
-        if self._backend:
-            # TODO: calling this twice is gross, this deserves a refactor
-            # Make sure our backend picks up the new creds
-            # _ = self._backend.interface.communicate_login(key, anonymous)
-            pass
-
 
 def _login(
     *,
@@ -333,7 +339,4 @@ def _login(
     if not key:
         wlogin.prompt_api_key()
 
-    # make sure login credentials get to the backend
-    wlogin.propogate_login()
-
     return wlogin._key or False

wandb/sdk/wandb_run.py

@@ -207,6 +207,15 @@ class RunStatusChecker:
         self._network_status_thread.start()
         self._internal_messages_thread.start()
 
+    @staticmethod
+    def _abandon_status_check(
+        lock: threading.Lock,
+        handle: Optional[MailboxHandle],
+    ):
+        with lock:
+            if handle:
+                handle.abandon()
+
     def _loop_check_status(
         self,
         *,
@@ -247,7 +256,7 @@ class RunStatusChecker:
                 local_handle = None
 
             time_elapsed = time.monotonic() - time_probe
-            wait_time = max(self._stop_polling_interval - time_elapsed, 0)
+            wait_time = max(timeout - time_elapsed, 0)
             join_requested = self._join_event.wait(timeout=wait_time)
 
     def check_network_status(self) -> None:
@@ -265,13 +274,19 @@ class RunStatusChecker:
                         )
                     )
 
-        self._loop_check_status(
-            lock=self._network_status_lock,
-            set_handle=lambda x: setattr(self, "_network_status_handle", x),
-            timeout=self._retry_polling_interval,
-            request=self._interface.deliver_network_status,
-            process=_process_network_status,
-        )
+        try:
+            self._loop_check_status(
+                lock=self._network_status_lock,
+                set_handle=lambda x: setattr(self, "_network_status_handle", x),
+                timeout=self._retry_polling_interval,
+                request=self._interface.deliver_network_status,
+                process=_process_network_status,
+            )
+        except BrokenPipeError:
+            self._abandon_status_check(
+                self._network_status_lock,
+                self._network_status_handle,
+            )
 
     def check_stop_status(self) -> None:
         def _process_stop_status(result: Result) -> None:
@@ -283,13 +298,19 @@ class RunStatusChecker:
                     thread.interrupt_main()
                     return
 
-        self._loop_check_status(
-            lock=self._stop_status_lock,
-            set_handle=lambda x: setattr(self, "_stop_status_handle", x),
-            timeout=self._stop_polling_interval,
-            request=self._interface.deliver_stop_status,
-            process=_process_stop_status,
-        )
+        try:
+            self._loop_check_status(
+                lock=self._stop_status_lock,
+                set_handle=lambda x: setattr(self, "_stop_status_handle", x),
+                timeout=self._stop_polling_interval,
+                request=self._interface.deliver_stop_status,
+                process=_process_stop_status,
+            )
+        except BrokenPipeError:
+            self._abandon_status_check(
+                self._stop_status_lock,
+                self._stop_status_handle,
+            )
 
     def check_internal_messages(self) -> None:
         def _process_internal_messages(result: Result) -> None:
@@ -297,25 +318,34 @@ class RunStatusChecker:
             for msg in internal_messages.messages.warning:
                 wandb.termwarn(msg)
 
-        self._loop_check_status(
-            lock=self._internal_messages_lock,
-            set_handle=lambda x: setattr(self, "_internal_messages_handle", x),
-            timeout=1,
-            request=self._interface.deliver_internal_messages,
-            process=_process_internal_messages,
-        )
+        try:
+            self._loop_check_status(
+                lock=self._internal_messages_lock,
+                set_handle=lambda x: setattr(self, "_internal_messages_handle", x),
+                timeout=1,
+                request=self._interface.deliver_internal_messages,
+                process=_process_internal_messages,
+            )
+        except BrokenPipeError:
+            self._abandon_status_check(
+                self._internal_messages_lock,
+                self._internal_messages_handle,
+            )
 
     def stop(self) -> None:
         self._join_event.set()
-        with self._stop_status_lock:
-            if self._stop_status_handle:
-                self._stop_status_handle.abandon()
-        with self._network_status_lock:
-            if self._network_status_handle:
-                self._network_status_handle.abandon()
-        with self._internal_messages_lock:
-            if self._internal_messages_handle:
-                self._internal_messages_handle.abandon()
+        self._abandon_status_check(
+            self._stop_status_lock,
+            self._stop_status_handle,
+        )
+        self._abandon_status_check(
+            self._network_status_lock,
+            self._network_status_handle,
+        )
+        self._abandon_status_check(
+            self._internal_messages_lock,
+            self._internal_messages_handle,
+        )
 
     def join(self) -> None:
         self.stop()
@@ -676,6 +706,12 @@ class Run:
                 "step": self._settings.fork_from.value,
             }
 
+        if self._settings.resume_from is not None:
+            config[wandb_key]["branch_point"] = {
+                "run_id": self._settings.resume_from.run,
+                "step": self._settings.resume_from.value,
+            }
+
         self._config._update(config, ignore_locked=True)
 
         if sweep_config:
@@ -1400,6 +1436,10 @@ class Run:
         # self._printer.display(line)
 
     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")
+            return {}
         if not self._backend or not self._backend.interface:
             return {}
         handle = self._backend.interface.deliver_get_summary()
@@ -1792,7 +1832,7 @@ class Run:
             import wandb
 
             run = wandb.init()
-            run.log({"pr": wandb.plots.precision_recall(y_test, y_probas, labels)})
+            run.log({"pr": wandb.plot.pr_curve(y_test, y_probas, labels)})
             ```
 
             ### 3D Object
@@ -1853,7 +1893,7 @@ class Run:
         picked up automatically.
 
         A `base_path` may be provided to control the directory structure of
-        uploaded files. It should be a prefix of `glob_str`, and the direcotry
+        uploaded files. It should be a prefix of `glob_str`, and the directory
         structure beneath it is preserved. It's best understood through
         examples:
 
@@ -1911,7 +1951,11 @@ class Run:
             # Provide a better error message for a common misuse.
             wandb.termlog(f"{glob_str} is a cloud storage url, can't save file to W&B.")
             return []
-        glob_path = pathlib.Path(glob_str)
+        # NOTE: We use PurePath instead of Path because WindowsPath doesn't
+        # like asterisks and errors out in resolve(). It also makes logical
+        # sense: globs aren't real paths, they're just path-like strings.
+        glob_path = pathlib.PurePath(glob_str)
+        resolved_glob_path = pathlib.PurePath(os.path.abspath(glob_path))
 
         if base_path is not None:
             base_path = pathlib.Path(base_path)
@@ -1925,15 +1969,14 @@ class Run:
                 'wandb.save("/mnt/folder/file.h5", base_path="/mnt")',
                 repeat=False,
             )
-            base_path = glob_path.resolve().parent.parent
+            base_path = resolved_glob_path.parent.parent
 
         if policy not in ("live", "end", "now"):
             raise ValueError(
                 'Only "live", "end" and "now" policies are currently supported.'
             )
 
-        resolved_glob_path = glob_path.resolve()
-        resolved_base_path = base_path.resolve()
+        resolved_base_path = pathlib.PurePath(os.path.abspath(base_path))
 
         return self._save(
             resolved_glob_path,
@@ -1943,8 +1986,8 @@ class Run:
 
     def _save(
         self,
-        glob_path: pathlib.Path,
-        base_path: pathlib.Path,
+        glob_path: pathlib.PurePath,
+        base_path: pathlib.PurePath,
         policy: "PolicyName",
     ) -> List[str]:
         # Can't use is_relative_to() because that's added in Python 3.9,
@@ -2440,6 +2483,8 @@ class Run:
         self._telemetry_obj_active = True
         self._telemetry_flush()
 
+        self._detect_and_apply_job_inputs()
+
         # object is about to be returned to the user, don't let them modify it
         self._freeze()
 
@@ -2447,6 +2492,12 @@ class Run:
             if os.path.exists(self._settings.resume_fname):
                 os.remove(self._settings.resume_fname)
 
+    def _detect_and_apply_job_inputs(self) -> None:
+        """If the user has staged launch inputs, apply them to the run."""
+        from wandb.sdk.launch.inputs.internal import StagedLaunchInputs
+
+        StagedLaunchInputs().apply(self)
+
     def _make_job_source_reqs(self) -> Tuple[List[str], Dict[str, Any], Dict[str, Any]]:
         from wandb.util import working_set
 
@@ -2552,6 +2603,14 @@ class Run:
         self._console_stop()  # TODO: there's a race here with jupyter console logging
 
         assert self._backend and self._backend.interface
+
+        # get the server info before starting the defer state machine as
+        # it will stop communication with the server
+        server_info_handle = self._backend.interface.deliver_request_server_info()
+        result = server_info_handle.wait(timeout=-1)
+        assert result
+        self._server_info_response = result.response.server_info_response
+
         exit_handle = self._backend.interface.deliver_exit(self._exit_code)
         exit_handle.add_probe(on_probe=self._on_probe_exit)
 
@@ -2560,6 +2619,7 @@ class Run:
         #     self._exit_code, settings=self._settings, printer=self._printer
         # )
 
+        # wait for the exit to complete
         _ = exit_handle.wait(timeout=-1, on_progress=self._on_progress_exit)
 
         poll_exit_handle = self._backend.interface.deliver_poll_exit()
@@ -2577,16 +2637,11 @@ class Run:
 
         # dispatch all our final requests
 
-        server_info_handle = self._backend.interface.deliver_request_server_info()
         final_summary_handle = self._backend.interface.deliver_get_summary()
         sampled_history_handle = (
             self._backend.interface.deliver_request_sampled_history()
         )
 
-        result = server_info_handle.wait(timeout=-1)
-        assert result
-        self._server_info_response = result.response.server_info_response
-
         result = sampled_history_handle.wait(timeout=-1)
         assert result
         self._sampled_history = result.response.sampled_history_response
@@ -2705,12 +2760,23 @@ class Run:
                 if i not in valid:
                     raise wandb.Error(f"Unhandled define_metric() arg: summary op: {i}")
                 summary_ops.append(i)
+            with telemetry.context(run=self) as tel:
+                tel.feature.metric_summary = True
         goal_cleaned: Optional[str] = None
         if goal is not None:
             goal_cleaned = goal[:3].lower()
             valid_goal = {"min", "max"}
             if goal_cleaned not in valid_goal:
                 raise wandb.Error(f"Unhandled define_metric() arg: goal: {goal}")
+            with telemetry.context(run=self) as tel:
+                tel.feature.metric_goal = True
+        if hidden:
+            with telemetry.context(run=self) as tel:
+                tel.feature.metric_hidden = True
+        if step_sync:
+            with telemetry.context(run=self) as tel:
+                tel.feature.metric_step_sync = True
+
         m = wandb_metric.Metric(
             name=name,
             step_metric=step_metric,
@@ -2895,6 +2961,7 @@ class Run:
             api.use_artifact(
                 artifact.id,
                 entity_name=r.entity,
+                project_name=r.project,
                 use_as=use_as or artifact_or_name,
             )
         else:
@@ -2957,8 +3024,7 @@ class Run:
                     - `s3://bucket/path`
                 You can also pass an Artifact object created by calling
                 `wandb.Artifact`.
-            name: (str, optional) An artifact name. May be prefixed with entity/project.
-                Valid names can be in the following forms:
+            name: (str, optional) An artifact name. Valid names can be in the following forms:
                     - name:version
                     - name:alias
                     - digest
@@ -3604,7 +3670,11 @@ class Run:
         project_url = settings.project_url
         sweep_url = settings.sweep_url
 
-        run_state_str = "Resuming run" if settings.resumed else "Syncing run"
+        run_state_str = (
+            "Resuming run"
+            if settings.resumed or settings.resume_from
+            else "Syncing run"
+        )
         run_name = settings.run_name
         if not run_name:
             return
@@ -3658,7 +3728,7 @@ class Run:
     # FOOTER
     # ------------------------------------------------------------------------------
     # Note: All the footer methods are static methods since we want to share the printing logic
-    # with the service execution path that doesn't have acess to the run instance
+    # with the service execution path that doesn't have access to the run instance
     @staticmethod
     def _footer(
         sampled_history: Optional["SampledHistoryResponse"] = None,
@@ -3961,11 +4031,11 @@ class Run:
 
         # Render summary if available
         if summary:
-            final_summary = {
-                item.key: json.loads(item.value_json)
-                for item in summary.item
-                if not item.key.startswith("_")
-            }
+            final_summary = {}
+            for item in summary.item:
+                if item.key.startswith("_") or len(item.nested_key) > 0:
+                    continue
+                final_summary[item.key] = json.loads(item.value_json)
 
             logger.info("rendering summary")
             summary_rows = []