wandb 0.22.2__py3-none-musllinux_1_2_aarch64.whl → 0.22.3__py3-none-musllinux_1_2_aarch64.whl

wandb/sdk/wandb_run.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import functools
 import glob
 import json
@@ -33,7 +32,6 @@ from wandb.errors import CommError, UsageError
 from wandb.errors.links import url_registry
 from wandb.integration.torch import wandb_torch
 from wandb.plot import CustomChart, Visualize
-from wandb.proto import wandb_internal_pb2 as pb
 from wandb.proto.wandb_deprecated import Deprecated
 from wandb.proto.wandb_internal_pb2 import (
     MetricRecord,
@@ -44,7 +42,7 @@ from wandb.proto.wandb_internal_pb2 import (
 from wandb.sdk.artifacts._internal_artifact import InternalArtifact
 from wandb.sdk.artifacts.artifact import Artifact
 from wandb.sdk.internal import job_builder
-from wandb.sdk.lib import asyncio_compat, wb_logging
+from wandb.sdk.lib import wb_logging
 from wandb.sdk.lib.import_hooks import (
     register_post_import_hook,
     unregister_post_import_hook,
@@ -489,7 +487,7 @@ class Run:
 
     You can log data to a run with `wandb.Run.log()`. Anything you log using
     `wandb.Run.log()` is sent to that run. See
-    [Create an experiment](https://docs.wandb.ai/guides/track/launch) or
+    [Create an experiment](https://docs.wandb.ai/guides/track/create-an-experiment/) or
     [`wandb.init`](https://docs.wandb.ai/ref/python/init/) API reference page
     or more information.
 
@@ -1574,15 +1572,13 @@ class Run:
 
     @_log_to_run
     def _console_callback(self, name: str, data: str) -> None:
-        # logger.info("console callback: %s, %s", name, data)
         if self._backend and self._backend.interface:
-            self._backend.interface.publish_output(name, data)
+            # nowait=True so that this can be called from an asyncio context.
+            self._backend.interface.publish_output(name, data, nowait=True)
 
     @_log_to_run
     @_raise_if_finished
     def _console_raw_callback(self, name: str, data: str) -> None:
-        # logger.info("console callback: %s, %s", name, data)
-
         # NOTE: console output is only allowed on the process which installed the callback
         # this will prevent potential corruption in the socket to the service.  Other methods
         # are protected by the _attach run decorator, but this callback was installed on the
@@ -1592,7 +1588,8 @@ class Run:
             return
 
         if self._backend and self._backend.interface:
-            self._backend.interface.publish_output_raw(name, data)
+            # nowait=True so that this can be called from an asyncio context.
+            self._backend.interface.publish_output_raw(name, data, nowait=True)
 
     @_log_to_run
     def _tensorboard_callback(
@@ -1861,7 +1858,7 @@ class Run:
             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)
+            run.log({"accuracy": 0.9}, step=current_step, commit=True)
         ```
 
         Args:
@@ -2682,41 +2679,6 @@ class Run:
         else:
             return artifact
 
-    async def _display_finish_stats(
-        self,
-        progress_printer: progress.ProgressPrinter,
-    ) -> None:
-        last_result: Result | None = None
-
-        async def loop_update_printer() -> None:
-            while True:
-                if last_result:
-                    progress_printer.update(
-                        [last_result.response.poll_exit_response],
-                    )
-                await asyncio.sleep(0.1)
-
-        async def loop_poll_exit() -> None:
-            nonlocal last_result
-            assert self._backend and self._backend.interface
-
-            while True:
-                handle = await self._backend.interface.deliver_async(
-                    pb.Record(request=pb.Request(poll_exit=pb.PollExitRequest()))
-                )
-
-                time_start = time.monotonic()
-                last_result = await handle.wait_async(timeout=None)
-
-                # Update at most once a second.
-                time_elapsed = time.monotonic() - time_start
-                if time_elapsed < 1:
-                    await asyncio.sleep(1 - time_elapsed)
-
-        async with asyncio_compat.open_task_group() as task_group:
-            task_group.start_soon(loop_update_printer())
-            task_group.start_soon(loop_poll_exit())
-
     def _on_finish(self) -> None:
         trigger.call("on_finished")
 
@@ -2741,8 +2703,9 @@ class Run:
                 exit_handle,
                 timeout=None,
                 display_progress=functools.partial(
-                    self._display_finish_stats,
+                    progress.loop_printing_operation_stats,
                     progress_printer,
+                    self._backend.interface,
                 ),
             )
 

wandb/sdk/wandb_settings.py

@@ -254,7 +254,40 @@ class Settings(BaseModel, validate_assignment=True):
     """
 
     console_multipart: bool = False
-    """Whether to produce multipart console log files."""
+    """Enable multipart console logging.
+
+    When True, the SDK writes console output to timestamped files
+    under the `logs/` directory instead of a single `output.log`.
+
+    Each part is uploaded as soon as it is closed, giving users live
+    access to logs while the run is active. Rollover cadence is
+    controlled by `console_chunk_max_bytes` and/or `console_chunk_max_seconds`.
+    If both limits are `0`, all logs are uploaded once at run finish.
+
+    Note: Uploaded chunks are immutable; terminal control sequences
+    that modify previous lines (e.g., progress bars using carriage returns)
+    only affect the current chunk.
+    """
+
+    console_chunk_max_bytes: int = 0
+    """Size-based rollover threshold for multipart console logs, in bytes.
+
+    Starts a new console log file when the current part reaches this
+    size. Has an effect only when `console_multipart` is `True`.
+    Can be combined with `console_chunk_max_seconds`; whichever limit is
+    hit first triggers the rollover. A value of `0` disables the
+    size-based limit.
+    """
+
+    console_chunk_max_seconds: int = 0
+    """Time-based rollover threshold for multipart console logs, in seconds.
+
+    Starts a new console log file after this many seconds have elapsed
+    since the current part began. Requires `console_multipart` to be
+    `True`.  May be used with `console_chunk_max_bytes`; the first limit
+    reached closes the part. A value of `0` disables the time-based
+    limit.
+    """
 
     credentials_file: str = Field(
         default_factory=lambda: str(credentials.DEFAULT_WANDB_CREDENTIALS_FILE)
@@ -1084,6 +1117,30 @@ class Settings(BaseModel, validate_assignment=True):
 
         return "wrap"
 
+    @field_validator("console_chunk_max_bytes", mode="after")
+    @classmethod
+    def validate_console_chunk_max_bytes(cls, value):
+        """Validate the console_chunk_max_bytes value.
+
+        <!-- lazydoc-ignore: internal -->
+        """
+        if value < 0:
+            raise ValueError("console_chunk_max_bytes must be non-negative")
+
+        return value
+
+    @field_validator("console_chunk_max_seconds", mode="after")
+    @classmethod
+    def validate_console_chunk_max_seconds(cls, value):
+        """Validate the console_chunk_max_seconds value.
+
+        <!-- lazydoc-ignore: internal -->
+        """
+        if value < 0:
+            raise ValueError("console_chunk_max_seconds must be non-negative")
+
+        return value
+
     @field_validator("x_executable", mode="before")
     @classmethod
     def validate_x_executable(cls, value):
@@ -1914,24 +1971,7 @@ class Settings(BaseModel, validate_assignment=True):
         program = self.program or self._get_program()
 
         if program is not None:
-            try:
-                root = (
-                    GitRepo().root or os.getcwd()
-                    if not self.disable_git
-                    else os.getcwd()
-                )
-            except Exception:
-                # if the git command fails, fall back to the current working directory
-                root = os.getcwd()
-
-            self.program_relpath = self.program_relpath or self._get_program_relpath(
-                program, root
-            )
-            program_abspath = os.path.abspath(
-                os.path.join(root, os.path.relpath(os.getcwd(), root), program)
-            )
-            if os.path.exists(program_abspath):
-                self.program_abspath = program_abspath
+            self._setup_code_paths(program)
         else:
             program = "<python with no main file>"
 
@@ -2196,3 +2236,46 @@ class Settings(BaseModel, validate_assignment=True):
             This is a compatibility property for Pydantic v1 to mimic v2's model_fields_set.
             """
             return getattr(self, "__fields_set__", set())
+
+    def _setup_code_paths(self, program: str):
+        """Sets the program_abspath and program_relpath settings."""
+        if self._jupyter and self.x_jupyter_root:
+            self._infer_code_paths_for_jupyter(program)
+        else:
+            self._infer_code_path_for_program(program)
+
+    def _infer_code_path_for_program(self, program: str):
+        """Finds the program's absolute and relative paths."""
+        try:
+            root = (
+                GitRepo().root or os.getcwd() if not self.disable_git else os.getcwd()
+            )
+        except Exception:
+            # if the git command fails, fall back to the current working directory
+            root = os.getcwd()
+
+        self.program_relpath = self.program_relpath or self._get_program_relpath(
+            program, root
+        )
+
+        program_abspath = os.path.abspath(
+            os.path.join(root, os.path.relpath(os.getcwd(), root), program)
+        )
+
+        if os.path.exists(program_abspath):
+            self.program_abspath = program_abspath
+
+    def _infer_code_paths_for_jupyter(self, program: str):
+        """Find the notebook's absolute and relative paths.
+
+        Since the notebook's execution environment
+        is not the same as the current working directory.
+        We utilize the metadata provided by the jupyter server.
+        """
+        if not self.x_jupyter_root or not program:
+            return None
+
+        self.program_abspath = os.path.abspath(
+            os.path.join(self.x_jupyter_root, program)
+        )
+        self.program_relpath = program

{wandb-0.22.2.dist-info → wandb-0.22.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wandb
-Version: 0.22.2
+Version: 0.22.3
 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
@@ -42,6 +42,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Logging