wandb 0.17.4__py3-none-win_amd64.whl → 0.17.6__py3-none-win_amd64.whl

wandb/sdk/wandb_run.py

@@ -235,10 +235,10 @@ class RunStatusChecker:
 
             with lock:
                 if self._join_event.is_set():
-                    return
+                    break
                 set_handle(local_handle)
             try:
-                result = local_handle.wait(timeout=timeout)
+                result = local_handle.wait(timeout=timeout, release=False)
             except MailboxError:
                 # background threads are oportunistically getting results
                 # from the internal process but the internal process could
@@ -253,6 +253,7 @@ class RunStatusChecker:
             if result:
                 process(result)
                 # if request finished, clear the handle to send on the next interval
+                local_handle.abandon()
                 local_handle = None
 
             time_elapsed = time.monotonic() - time_probe
@@ -591,8 +592,12 @@ class Run:
     ) -> None:
         # pid is set, so we know if this run object was initialized by this process
         self._init_pid = os.getpid()
+        self._settings = settings
+
+        if settings._noop:
+            return
+
         self._init(
-            settings=settings,
             config=config,
             sweep_config=sweep_config,
             launch_config=launch_config,
@@ -600,12 +605,10 @@ 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,
     ) -> None:
-        self._settings = settings
         self._config = wandb_config.Config()
         self._config._set_callback(self._config_callback)
         self._config._set_artifact_callback(self._config_artifact_callback)
@@ -2100,36 +2103,56 @@ class Run:
         return self._finish(exit_code, quiet)
 
     def _finish(
-        self, exit_code: Optional[int] = None, quiet: Optional[bool] = None
+        self,
+        exit_code: Optional[int] = None,
+        quiet: Optional[bool] = None,
     ) -> None:
-        if quiet is not None:
-            self._quiet = quiet
+        logger.info(f"finishing run {self._get_path()}")
         with telemetry.context(run=self) as tel:
             tel.feature.finish = True
-        logger.info(f"finishing run {self._get_path()}")
-        # detach jupyter hooks / others that needs to happen before backend shutdown
-        for hook in self._teardown_hooks:
-            if hook.stage == TeardownStage.EARLY:
-                hook.call()
 
-        self._atexit_cleanup(exit_code=exit_code)
+        if quiet is not None:
+            self._quiet = quiet
+
+        # Pop this run (hopefully) from the run stack, to support the "reinit"
+        # functionality of wandb.init().
+        #
+        # TODO: It's not clear how _global_run_stack could have length other
+        # than 1 at this point in the code. If you're reading this, consider
+        # refactoring this thing.
         if self._wl and len(self._wl._global_run_stack) > 0:
             self._wl._global_run_stack.pop()
-        # detach logger / others meant to be run after we've shutdown the backend
+
+        # Run hooks that need to happen before the last messages to the
+        # internal service, like Jupyter hooks.
         for hook in self._teardown_hooks:
-            if hook.stage == TeardownStage.LATE:
+            if hook.stage == TeardownStage.EARLY:
                 hook.call()
-        self._teardown_hooks = []
-        module.unset_globals()
-
-        # inform manager this run is finished
-        manager = self._wl and self._wl._get_manager()
-        if manager:
-            manager._inform_finish(run_id=self._run_id)
 
+        # Early-stage hooks may use methods that require _is_finished
+        # to be False, so we set this after running those hooks.
         self._is_finished = True
-        # end sentry session
-        wandb._sentry.end_session()
+
+        try:
+            self._atexit_cleanup(exit_code=exit_code)
+
+            # Run hooks that should happen after the last messages to the
+            # internal service, like detaching the logger.
+            for hook in self._teardown_hooks:
+                if hook.stage == TeardownStage.LATE:
+                    hook.call()
+            self._teardown_hooks = []
+
+            # Inform the service that we're done sending messages for this run.
+            #
+            # TODO: Why not do this in _atexit_cleanup()?
+            manager = self._wl and self._wl._get_manager()
+            if manager:
+                manager._inform_finish(run_id=self._run_id)
+
+        finally:
+            module.unset_globals()
+            wandb._sentry.end_session()
 
     @_run_decorator._noop
     @_run_decorator._attach
@@ -2345,36 +2368,49 @@ class Run:
             return
         self._atexit_cleanup_called = True
 
-        exit_code = exit_code or self._hooks.exit_code if self._hooks else 0
+        exit_code = (
+            exit_code  #
+            or (self._hooks and self._hooks.exit_code)
+            or 0
+        )
+        self._exit_code = exit_code
         logger.info(f"got exitcode: {exit_code}")
+
+        # Delete this run's "resume" file if the run finished successfully.
+        #
+        # This is used by the "auto" resume mode, which resumes from the last
+        # failed (or unfinished/crashed) run. If we reach this line, then this
+        # run shouldn't be a candidate for "auto" resume.
         if exit_code == 0:
-            # Cleanup our resume file on a clean exit
             if os.path.exists(self._settings.resume_fname):
                 os.remove(self._settings.resume_fname)
 
-        self._exit_code = exit_code
-        report_failure = False
         try:
             self._on_finish()
-        except KeyboardInterrupt as ki:
-            if wandb.wandb_agent._is_running():
-                raise ki
-            wandb.termerror("Control-C detected -- Run data was not synced")
-            if not self._settings._notebook:
-                os._exit(-1)
+
+        except KeyboardInterrupt:
+            if not wandb.wandb_agent._is_running():
+                wandb.termerror("Control-C detected -- Run data was not synced")
+            raise
+
         except Exception as e:
-            if not self._settings._notebook:
-                report_failure = True
             self._console_stop()
-            self._backend.cleanup()
             logger.error("Problem finishing run", exc_info=e)
             wandb.termerror("Problem finishing run")
-            traceback.print_exc()
-        else:
-            self._on_final()
-        finally:
-            if report_failure:
-                os._exit(-1)
+            raise
+
+        Run._footer(
+            sampled_history=self._sampled_history,
+            final_summary=self._final_summary,
+            poll_exit_response=self._poll_exit_response,
+            server_info_response=self._server_info_response,
+            check_version_response=self._check_version,
+            internal_messages_response=self._internal_messages_response,
+            reporter=self._reporter,
+            quiet=self._quiet,
+            settings=self._settings,
+            printer=self._printer,
+        )
 
     def _console_start(self) -> None:
         logger.info("atexit reg")
@@ -2659,20 +2695,6 @@ class Run:
         for module_name in import_telemetry_set:
             unregister_post_import_hook(module_name, run_id)
 
-    def _on_final(self) -> None:
-        self._footer(
-            sampled_history=self._sampled_history,
-            final_summary=self._final_summary,
-            poll_exit_response=self._poll_exit_response,
-            server_info_response=self._server_info_response,
-            check_version_response=self._check_version,
-            internal_messages_response=self._internal_messages_response,
-            reporter=self._reporter,
-            quiet=self._quiet,
-            settings=self._settings,
-            printer=self._printer,
-        )
-
     @_run_decorator._noop_on_finish()
     @_run_decorator._attach
     def define_metric(
@@ -2684,29 +2706,48 @@ class Run:
         summary: Optional[str] = None,
         goal: Optional[str] = None,
         overwrite: Optional[bool] = None,
-        **kwargs: Any,
     ) -> wandb_metric.Metric:
-        """Define metric properties which will later be logged with `wandb.log()`.
+        """Customize metrics logged with `wandb.log()`.
 
         Arguments:
-            name: Name of the metric.
-            step_metric: Independent variable associated with the metric.
-            step_sync: Automatically add `step_metric` to history if needed.
-                Defaults to True if step_metric is specified.
+            name: The name of the metric to customize.
+            step_metric: The name of another metric to serve as the X-axis
+                for this metric in automatically generated charts.
+            step_sync: Automatically insert the last value of step_metric into
+                `run.log()` if it is not provided explicitly. Defaults to True
+                 if step_metric is specified.
             hidden: Hide this metric from automatic plots.
             summary: Specify aggregate metrics added to summary.
-                Supported aggregations: "min,max,mean,best,last,none"
-                Default aggregation is `copy`
-                Aggregation `best` defaults to `goal`==`minimize`
-            goal: Specify direction for optimizing the metric.
-                Supported directions: "minimize,maximize"
+                Supported aggregations include "min", "max", "mean", "last",
+                "best", "copy" and "none". "best" is used together with the
+                goal parameter. "none" prevents a summary from being generated.
+                "copy" is deprecated and should not be used.
+            goal: Specify how to interpret the "best" summary type.
+                Supported options are "minimize" and "maximize".
+            overwrite: If false, then this call is merged with previous
+                `define_metric` calls for the same metric by using their
+                values for any unspecified parameters. If true, then
+                unspecified parameters overwrite values specified by
+                previous calls.
 
         Returns:
-            A metric object is returned that can be further specified.
-
+            An object that represents this call but can otherwise be discarded.
         """
+        if summary and "copy" in summary:
+            deprecate.deprecate(
+                deprecate.Deprecated.run__define_metric_copy,
+                "define_metric(summary='copy') is deprecated and will be removed.",
+                self,
+            )
+
         return self._define_metric(
-            name, step_metric, step_sync, hidden, summary, goal, overwrite, **kwargs
+            name,
+            step_metric,
+            step_sync,
+            hidden,
+            summary,
+            goal,
+            overwrite,
         )
 
     def _define_metric(
@@ -2718,12 +2759,9 @@ class Run:
         summary: Optional[str] = None,
         goal: Optional[str] = None,
         overwrite: Optional[bool] = None,
-        **kwargs: Any,
     ) -> wandb_metric.Metric:
         if not name:
             raise wandb.Error("define_metric() requires non-empty name argument")
-        for k in kwargs:
-            wandb.termwarn(f"Unhandled define_metric() arg: {k}")
         if isinstance(step_metric, wandb_metric.Metric):
             step_metric = step_metric.name
         for arg_name, arg_val, exp_type in (
@@ -2878,7 +2916,7 @@ class Run:
             if artifact.is_draft() and not artifact._is_draft_save_started():
                 artifact = self._log_artifact(artifact)
             if not self._settings._offline:
-                self._backend.interface.publish_link_artifact(
+                handle = self._backend.interface.deliver_link_artifact(
                     self,
                     artifact,
                     portfolio,
@@ -2890,6 +2928,13 @@ class Run:
                     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
@@ -3836,34 +3881,33 @@ class Run:
         if not poll_exit_response:
             return
 
-        progress = poll_exit_response.pusher_stats
-        done = poll_exit_response.done
+        stats = poll_exit_response.pusher_stats
 
         megabyte = wandb.util.POW_2_BYTES[2][1]
-        line = f"{progress.uploaded_bytes / megabyte :.3f} MB of {progress.total_bytes / megabyte:.3f} MB uploaded"
-        if progress.deduped_bytes > 0:
-            line += f" ({progress.deduped_bytes / megabyte:.3f} MB deduped)\r"
-        else:
-            line += "\r"
-
-        percent_done = (
-            1.0
-            if progress.total_bytes == 0
-            else progress.uploaded_bytes / progress.total_bytes
+        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"
 
-        printer.progress_update(line, percent_done)
-        if done:
+        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()
 
-            dedupe_fraction = (
-                progress.deduped_bytes / float(progress.total_bytes)
-                if progress.total_bytes > 0
-                else 0
-            )
-            if dedupe_fraction > 0.01:
+            if stats.total_bytes > 0:
+                dedupe_fraction = stats.deduped_bytes / float(stats.total_bytes)
+            else:
+                dedupe_fraction = 0
+
+            if stats.deduped_bytes > 0.01:
                 printer.display(
-                    f"W&B sync reduced upload amount by {dedupe_fraction * 100:.1f}%             "
+                    f"W&B sync reduced upload amount by {dedupe_fraction:.1%}"
                 )
 
     @staticmethod

wandb/sdk/wandb_settings.py

@@ -1882,9 +1882,10 @@ class Settings(SettingsData):
         if self.resume_from is None:
             return
 
-        if self.run_id is not None:
+        if self.run_id is not None and (self.resume_from.run != self.run_id):
             wandb.termwarn(
-                "You cannot specify both run_id and resume_from. " "Ignoring run_id."
+                "Both `run_id` and `resume_from` have been specified with different ids. "
+                "`run_id` will be ignored."
             )
         self.update({"run_id": self.resume_from.run}, source=Source.INIT)
 

wandb/util.py

@@ -1748,21 +1748,39 @@ def make_docker_image_name_safe(name: str) -> str:
     return trimmed if trimmed else "image"
 
 
-def merge_dicts(source: Dict[str, Any], destination: Dict[str, Any]) -> Dict[str, Any]:
-    """Recursively merge two dictionaries."""
+def merge_dicts(
+    source: Dict[str, Any],
+    destination: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Recursively merge two dictionaries.
+
+    This mutates the destination and its nested dictionaries and lists.
+
+    Instances of `dict` are recursively merged and instances of `list`
+    are appended to the destination. If the destination type is not
+    `dict` or `list`, respectively, the key is overwritten with the
+    source value.
+
+    For all other types, the source value overwrites the destination value.
+    """
     for key, value in source.items():
         if isinstance(value, dict):
-            # get node or create one
-            node = destination.setdefault(key, {})
-            merge_dicts(value, node)
-        else:
-            if isinstance(value, list):
-                if key in destination:
-                    destination[key].extend(value)
-                else:
-                    destination[key] = value
+            node = destination.get(key)
+            if isinstance(node, dict):
+                merge_dicts(value, node)
             else:
                 destination[key] = value
+
+        elif isinstance(value, list):
+            dest_value = destination.get(key)
+            if isinstance(dest_value, list):
+                dest_value.extend(value)
+            else:
+                destination[key] = value
+
+        else:
+            destination[key] = value
+
     return destination
 
 

wandb/wandb_agent.py

@@ -43,6 +43,8 @@ class AgentProcess:
                 kwargs = dict(creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
             else:
                 kwargs = dict(preexec_fn=os.setpgrp)
+            if env.get(wandb.env.SERVICE):
+                env.pop(wandb.env.SERVICE)
             self._popen = subprocess.Popen(command, env=env, **kwargs)
         elif function:
             self._proc = multiprocessing.Process(

{wandb-0.17.4.dist-info → wandb-0.17.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wandb
-Version: 0.17.4
+Version: 0.17.6
 Summary: A CLI and library for interacting with the Weights & Biases API.
 Project-URL: Source, https://github.com/wandb/wandb
 Project-URL: Bug Reports, https://github.com/wandb/wandb/issues
@@ -71,7 +71,7 @@ Requires-Dist: google-cloud-storage; extra == 'gcp'
 Provides-Extra: importers
 Requires-Dist: filelock; extra == 'importers'
 Requires-Dist: mlflow; extra == 'importers'
-Requires-Dist: polars; extra == 'importers'
+Requires-Dist: polars<=1.2.1; extra == 'importers'
 Requires-Dist: rich; extra == 'importers'
 Requires-Dist: tenacity; extra == 'importers'
 Provides-Extra: kubeflow
@@ -93,6 +93,7 @@ Requires-Dist: google-cloud-artifact-registry; extra == 'launch'
 Requires-Dist: google-cloud-compute; extra == 'launch'
 Requires-Dist: google-cloud-storage; extra == 'launch'
 Requires-Dist: iso8601; extra == 'launch'
+Requires-Dist: jsonschema; extra == 'launch'
 Requires-Dist: kubernetes; extra == 'launch'
 Requires-Dist: kubernetes-asyncio; extra == 'launch'
 Requires-Dist: nbconvert; extra == 'launch'