wandb 0.17.5__py3-none-win32.whl → 0.17.7__py3-none-win32.whl

wandb/sdk/wandb_run.py

@@ -42,6 +42,7 @@ from wandb._globals import _datatypes_set_callback
 from wandb.apis import internal, public
 from wandb.apis.internal import Api
 from wandb.apis.public import Api as PublicApi
+from wandb.errors import CommError
 from wandb.proto.wandb_internal_pb2 import (
     MetricRecord,
     PollExitResponse,
@@ -69,7 +70,7 @@ from wandb.viz import CustomChart, Visualize, custom_chart
 
 from . import wandb_config, wandb_metric, wandb_summary
 from .data_types._dtypes import TypeRegistry
-from .interface.interface import GlobStr, InterfaceBase
+from .interface.interface import FilesDict, GlobStr, InterfaceBase, PolicyName
 from .interface.summary_record import SummaryRecord
 from .lib import (
     config_util,
@@ -89,6 +90,7 @@ from .lib.printer import get_printer
 from .lib.proto_util import message_to_dict
 from .lib.reporting import Reporter
 from .lib.wburls import wburls
+from .wandb_alerts import AlertLevel
 from .wandb_settings import Settings
 from .wandb_setup import _WandbSetup
 
@@ -108,9 +110,7 @@ if TYPE_CHECKING:
         SampledHistoryResponse,
     )
 
-    from .interface.interface import FilesDict, PolicyName
     from .lib.printer import PrinterJupyter, PrinterTerm
-    from .wandb_alerts import AlertLevel
 
     class GitSourceDict(TypedDict):
         remote: str
@@ -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
@@ -294,7 +295,7 @@ class RunStatusChecker:
             if stop_status.run_should_stop:
                 # TODO(frz): This check is required
                 # until WB-3606 is resolved on server side.
-                if not wandb.agents.pyagent.is_running():
+                if not wandb.agents.pyagent.is_running():  # type: ignore
                     thread.interrupt_main()
                     return
 
@@ -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)
@@ -618,7 +621,7 @@ class Run:
         )
         self.summary._set_update_callback(self._summary_update_callback)
         self._step = 0
-        self._torch_history: Optional[wandb.wandb_torch.TorchHistory] = None
+        self._torch_history: Optional[wandb.wandb_torch.TorchHistory] = 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,
@@ -917,9 +920,9 @@ class Run:
         self.__dict__.update(state)
 
     @property
-    def _torch(self) -> "wandb.wandb_torch.TorchHistory":
+    def _torch(self) -> "wandb.wandb_torch.TorchHistory":  # type: ignore
         if self._torch_history is None:
-            self._torch_history = wandb.wandb_torch.TorchHistory()
+            self._torch_history = wandb.wandb_torch.TorchHistory()  # type: ignore
         return self._torch_history
 
     @property
@@ -1086,13 +1089,14 @@ class Run:
     @_run_decorator._attach
     def mode(self) -> str:
         """For compatibility with `0.9.x` and earlier, deprecate eventually."""
-        deprecate.deprecate(
-            field_name=deprecate.Deprecated.run__mode,
-            warning_message=(
-                "The mode property of wandb.run is deprecated "
-                "and will be removed in a future release."
-            ),
-        )
+        if hasattr(self, "_telemetry_obj"):
+            deprecate.deprecate(
+                field_name=deprecate.Deprecated.run__mode,
+                warning_message=(
+                    "The mode property of wandb.run is deprecated "
+                    "and will be removed in a future release."
+                ),
+            )
         return "dryrun" if self._settings._offline else "run"
 
     @property
@@ -1672,15 +1676,15 @@ class Run:
         commit: Optional[bool] = None,
         sync: Optional[bool] = None,
     ) -> None:
-        """Log a dictionary of data to the current run's history.
+        """Upload run data.
 
-        Use `wandb.log` to log data from runs, such as scalars, images, video,
+        Use `log` to log data from runs, such as scalars, images, video,
         histograms, plots, and tables.
 
         See our [guides to logging](https://docs.wandb.ai/guides/track/log) for
         live examples, code snippets, best practices, and more.
 
-        The most basic usage is `wandb.log({"train-loss": 0.5, "accuracy": 0.9})`.
+        The most basic usage is `run.log({"train-loss": 0.5, "accuracy": 0.9})`.
         This will save the loss and accuracy to the run's history and update
         the summary values for these metrics.
 
@@ -1689,48 +1693,91 @@ class Run:
         of the W&B app, or export data to visualize and explore locally, e.g. in
         Jupyter notebooks, with [our API](https://docs.wandb.ai/guides/track/public-api-guide).
 
-        In the UI, summary values show up in the run table to compare single values across runs.
-        Summary values can also be set directly with `wandb.run.summary["key"] = value`.
-
         Logged values don't have to be scalars. Logging any wandb object is supported.
-        For example `wandb.log({"example": wandb.Image("myimage.jpg")})` will log an
+        For example `run.log({"example": wandb.Image("myimage.jpg")})` will log an
         example image which will be displayed nicely in the W&B UI.
         See the [reference documentation](https://docs.wandb.com/ref/python/data-types)
         for all of the different supported types or check out our
         [guides to logging](https://docs.wandb.ai/guides/track/log) for examples,
         from 3D molecular structures and segmentation masks to PR curves and histograms.
-        `wandb.Table`s can be used to logged structured data. See our
+        You can use `wandb.Table` to log structured data. See our
         [guide to logging tables](https://docs.wandb.ai/guides/data-vis/log-tables)
         for details.
 
-        Logging nested metrics is encouraged and is supported in the W&B UI.
-        If you log with a nested dictionary like `wandb.log({"train":
-        {"acc": 0.9}, "val": {"acc": 0.8}})`, the metrics will be organized into
-        `train` and `val` sections in the W&B UI.
+        The W&B UI organizes metrics with a forward slash (`/`) in their name
+        into sections named using the text before the final slash. For example,
+        the following results in two sections named "train" and "validate":
+
+        ```
+        run.log({
+            "train/accuracy": 0.9,
+            "train/loss": 30,
+            "validate/accuracy": 0.8,
+            "validate/loss": 20,
+        })
+        ```
+
+        Only one level of nesting is supported; `run.log({"a/b/c": 1})`
+        produces a section named "a/b".
+
+        `run.log` is not intended to be called more than a few times per second.
+        For optimal performance, limit your logging to once every N iterations,
+        or collect data over multiple iterations and log it in a single step.
+
+        ### The W&B step
 
-        wandb keeps track of a global step, which by default increments with each
-        call to `wandb.log`, so logging related metrics together is encouraged.
-        If it's inconvenient to log related metrics together
-        calling `wandb.log({"train-loss": 0.5}, commit=False)` and then
-        `wandb.log({"accuracy": 0.9})` is equivalent to calling
-        `wandb.log({"train-loss": 0.5, "accuracy": 0.9})`.
+        With basic usage, each call to `log` creates a new "step".
+        The step must always increase, and it is not possible to log
+        to a previous step.
 
-        `wandb.log` is not intended to be called more than a few times per second.
-        If you want to log more frequently than that it's better to aggregate
-        the data on the client side or you may get degraded performance.
+        Note that you can use any metric as the X axis in charts.
+        In many cases, it is better to treat the W&B step like
+        you'd treat a timestamp rather than a training step.
+
+        ```
+        # Example: log an "epoch" metric for use as an X axis.
+        run.log({"epoch": 40, "train-loss": 0.5})
+        ```
+
+        See also [define_metric](https://docs.wandb.ai/ref/python/run#define_metric).
+
+        It is possible to use multiple `log` invocations to log to
+        the same step with the `step` and `commit` parameters.
+        The following are all equivalent:
+
+        ```
+        # Normal usage:
+        run.log({"train-loss": 0.5, "accuracy": 0.8})
+        run.log({"train-loss": 0.4, "accuracy": 0.9})
+
+        # Implicit step without auto-incrementing:
+        run.log({"train-loss": 0.5}, commit=False)
+        run.log({"accuracy": 0.8})
+        run.log({"train-loss": 0.4}, commit=False)
+        run.log({"accuracy": 0.9})
+
+        # Explicit step:
+        run.log({"train-loss": 0.5}, step=current_step)
+        run.log({"accuracy": 0.8}, step=current_step)
+        current_step += 1
+        run.log({"train-loss": 0.4}, step=current_step)
+        run.log({"accuracy": 0.9}, step=current_step)
+        ```
 
         Arguments:
-            data: (dict, optional) A dict of serializable python objects i.e `str`,
-                `ints`, `floats`, `Tensors`, `dicts`, or any of the `wandb.data_types`.
-            commit: (boolean, optional) Save the metrics dict to the wandb server
-                and increment the step.  If false `wandb.log` just updates the current
-                metrics dict with the data argument and metrics won't be saved until
-                `wandb.log` is called with `commit=True`.
-            step: (integer, optional) The global step in processing. This persists
-                any non-committed earlier steps but defaults to not committing the
-                specified step.
-            sync: (boolean, True) This argument is deprecated and currently doesn't
-                change the behaviour of `wandb.log`.
+            data: A `dict` with `str` keys and values that are serializable
+                Python objects including: `int`, `float` and `string`;
+                any of the `wandb.data_types`; lists, tuples and NumPy arrays
+                of serializable Python objects; other `dict`s of this
+                structure.
+            step: The step number to log. If `None`, then an implicit
+                auto-incrementing step is used. See the notes in
+                the description.
+            commit: If true, finalize and upload the step. If false, then
+                accumulate data for the step. See the notes in the description.
+                If `step` is `None`, then the default is `commit=True`;
+                otherwise, the default is `commit=False`.
+            sync: This argument is deprecated and does nothing.
 
         Examples:
             For more and more detailed examples, see
@@ -1882,7 +1929,7 @@ class Run:
         self,
         glob_str: Optional[Union[str, os.PathLike]] = None,
         base_path: Optional[Union[str, os.PathLike]] = None,
-        policy: "PolicyName" = "live",
+        policy: PolicyName = "live",
     ) -> Union[bool, List[str]]:
         """Sync one or more files to W&B.
 
@@ -2155,12 +2202,13 @@ class Run:
     @_run_decorator._attach
     def join(self, exit_code: Optional[int] = None) -> None:
         """Deprecated alias for `finish()` - use finish instead."""
-        deprecate.deprecate(
-            field_name=deprecate.Deprecated.run__join,
-            warning_message=(
-                "wandb.run.join() is deprecated, please use wandb.run.finish()."
-            ),
-        )
+        if hasattr(self, "_telemetry_obj"):
+            deprecate.deprecate(
+                field_name=deprecate.Deprecated.run__join,
+                warning_message=(
+                    "wandb.run.join() is deprecated, please use wandb.run.finish()."
+                ),
+            )
         self._finish(exit_code=exit_code)
 
     @_run_decorator._noop_on_finish()
@@ -2365,11 +2413,7 @@ class Run:
             return
         self._atexit_cleanup_called = True
 
-        exit_code = (
-            exit_code  #
-            or (self._hooks and self._hooks.exit_code)
-            or 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}")
 
@@ -2386,7 +2430,7 @@ class Run:
             self._on_finish()
 
         except KeyboardInterrupt:
-            if not wandb.wandb_agent._is_running():
+            if not wandb.wandb_agent._is_running():  # type: ignore
                 wandb.termerror("Control-C detected -- Run data was not synced")
             raise
 
@@ -2703,29 +2747,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(
@@ -2737,12 +2800,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 (
@@ -2820,12 +2880,12 @@ class Run:
         idx=None,
         log_graph=False,
     ) -> None:
-        wandb.watch(models, criterion, log, log_freq, idx, log_graph)
+        wandb.watch(models, criterion, log, log_freq, idx, log_graph)  # type: ignore
 
     # TODO(jhr): annotate this
     @_run_decorator._attach
     def unwatch(self, models=None) -> None:  # type: ignore
-        wandb.unwatch(models=models)
+        wandb.unwatch(models=models)  # type: ignore
 
     # TODO(kdg): remove all artifact swapping logic
     def _swap_artifact_name(self, artifact_name: str, use_as: Optional[str]) -> str:
@@ -3495,7 +3555,7 @@ class Run:
             artifact = self._log_artifact(
                 artifact_or_path=path, name=name, type=artifact.type
             )
-        except (ValueError, wandb.CommError):
+        except (ValueError, CommError):
             artifact = self._log_artifact(
                 artifact_or_path=path, name=name, type="model"
             )
@@ -3515,13 +3575,13 @@ class Run:
         Arguments:
             title: (str) The title of the alert, must be less than 64 characters long.
             text: (str) The text body of the alert.
-            level: (str or wandb.AlertLevel, optional) The alert level to use, either: `INFO`, `WARN`, or `ERROR`.
+            level: (str or AlertLevel, optional) The alert level to use, either: `INFO`, `WARN`, or `ERROR`.
             wait_duration: (int, float, or timedelta, optional) The time to wait (in seconds) before sending another
                 alert with this title.
         """
-        level = level or wandb.AlertLevel.INFO
-        level_str: str = level.value if isinstance(level, wandb.AlertLevel) else level
-        if level_str not in {lev.value for lev in wandb.AlertLevel}:
+        level = level or AlertLevel.INFO
+        level_str: str = level.value if isinstance(level, AlertLevel) else level
+        if level_str not in {lev.value for lev in AlertLevel}:
             raise ValueError("level must be one of 'INFO', 'WARN', or 'ERROR'")
 
         wait_duration = wait_duration or timedelta(minutes=1)
@@ -3704,12 +3764,12 @@ class Run:
             return
 
         if printer._html:
-            if not wandb.jupyter.maybe_display():
+            if not wandb.jupyter.maybe_display():  # type: ignore
                 run_line = f"<strong>{printer.link(run_url, run_name)}</strong>"
                 project_line, sweep_line = "", ""
 
                 # TODO(settings): make settings the source of truth
-                if not wandb.jupyter.quiet():
+                if not wandb.jupyter.quiet():  # type: ignore
                     doc_html = printer.link(wburls.get("doc_run"), "docs")
 
                     project_html = printer.link(project_url, "Weights & Biases")

wandb/sdk/wandb_settings.py

@@ -1715,7 +1715,7 @@ class Settings(SettingsData):
 
         # Attempt to get notebook information if not already set by the user
         if self._jupyter and (self.notebook_name is None or self.notebook_name == ""):
-            meta = wandb.jupyter.notebook_metadata(self.silent)
+            meta = wandb.jupyter.notebook_metadata(self.silent)  # type: ignore
             settings["_jupyter_path"] = meta.get("path")
             settings["_jupyter_name"] = meta.get("name")
             settings["_jupyter_root"] = meta.get("root")
@@ -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/sdk/wandb_setup.py

@@ -319,14 +319,77 @@ def _setup(
     return wl
 
 
-def setup(
-    settings: Optional[Settings] = None,
-) -> Optional["_WandbSetup"]:
+def setup(settings: Optional[Settings] = None) -> Optional["_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()`.
+
+    When using wandb in multiple processes, calling `wandb.setup()`
+    in the parent process before starting child processes may improve
+    performance and resource utilization.
+
+    Note that `wandb.setup()` modifies `os.environ`, and it is important
+    that child processes inherit the modified environment variables.
+
+    See also `wandb.teardown()`.
+
+    Args:
+        settings (Optional[Union[Dict[str, Any], wandb.Settings]]): Configuration settings
+            to apply globally. These can be overridden by subsequent `wandb.init()` calls.
+
+    Example:
+        ```python
+        import multiprocessing
+
+        import wandb
+
+
+        def run_experiment(params):
+            with wandb.init(config=params):
+                # Run experiment
+                pass
+
+
+        if __name__ == "__main__":
+            # Start backend and set global config
+            wandb.setup(settings={"project": "my_project"})
+
+            # Define experiment parameters
+            experiment_params = [
+                {"learning_rate": 0.01, "epochs": 10},
+                {"learning_rate": 0.001, "epochs": 20},
+            ]
+
+            # Start multiple processes, each running a separate experiment
+            processes = []
+            for params in experiment_params:
+                p = multiprocessing.Process(target=run_experiment, args=(params,))
+                p.start()
+                processes.append(p)
+
+            # Wait for all processes to complete
+            for p in processes:
+                p.join()
+
+            # Optional: Explicitly shut down the backend
+            wandb.teardown()
+        ```
+    """
     ret = _setup(settings=settings)
     return ret
 
 
 def teardown(exit_code: Optional[int] = None) -> None:
+    """Waits for wandb to finish and frees resources.
+
+    Completes any runs that were not explicitly finished
+    using `run.finish()` and waits for all data to be uploaded.
+
+    It is recommended to call this at the end of a session
+    that used `wandb.setup()`. It is invoked automatically
+    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
 

wandb/sdk/wandb_sweep.py

@@ -1,5 +1,5 @@
 import urllib.parse
-from typing import Callable, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Union
 
 import wandb
 from wandb import env
@@ -8,6 +8,9 @@ from wandb.sdk.launch.sweeps.utils import handle_sweep_config_violations
 
 from . import wandb_login
 
+if TYPE_CHECKING:
+    from wandb.wandb_controller import _WandbController
+
 
 def _get_sweep_url(api, sweep_id):
     """Return sweep url if we can figure it out."""
@@ -93,7 +96,7 @@ def controller(
     sweep_id_or_config: Optional[Union[str, Dict]] = None,
     entity: Optional[str] = None,
     project: Optional[str] = None,
-):
+) -> "_WandbController":
     """Public sweep controller constructor.
 
     Usage:

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.5.dist-info → wandb-0.17.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wandb
-Version: 0.17.5
+Version: 0.17.7
 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'