pivot 0.2.1__tar.gz → 0.2.2__tar.gz

{pivot-0.2.1 → pivot-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pivot
-Version: 0.2.1
+Version: 0.2.2
 Summary: High-performance Python pipeline tool with automatic code change detection
 Author: Sami Jawhar
 Author-email: Sami Jawhar <sami@metr.org>

{pivot-0.2.1 → pivot-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pivot"
-version = "0.2.1"
+version = "0.2.2"
 description = "High-performance Python pipeline tool with automatic code change detection"
 requires-python = ">=3.13,<3.14"
 readme = "README.md"

{pivot-0.2.1 → pivot-0.2.2}/src/pivot/engine/sinks.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import dataclasses
 import sys
 import time
 from typing import TYPE_CHECKING
@@ -10,8 +11,8 @@ import rich.live
 import rich.markup
 import rich.text
 
-from pivot.engine.types import StageCompleted
-from pivot.types import DisplayCategory, categorize_stage_result
+from pivot.engine.types import LogLine, StageCompleted
+from pivot.types import LOSSY_OUTPUT_PHRASE, DisplayCategory, categorize_stage_result
 
 if TYPE_CHECKING:
     from pivot.engine.types import OutputEvent
@@ -84,6 +85,20 @@ def _categorize(event: StageCompleted) -> DisplayCategory:
     return categorize_stage_result(event["status"])
 
 
+@dataclasses.dataclass
+class _StageWarnings:
+    """A stage's ``WARNING:`` lines for the report.
+
+    Pivot's own output-write warnings are always kept and print first. The stage's own
+    warnings are counted per distinct line (in first-seen order); the report shows the
+    first ``_MAX_LOG_LINES_PER_STAGE`` distinct lines and counts the rest.
+    """
+
+    stage: dict[str, int] = dataclasses.field(default_factory=dict[str, int])
+    lossy_outputs: list[str] = dataclasses.field(default_factory=list[str])
+    dropped: int = 0
+
+
 def _print_completions(
     console: rich.console.Console,
     events: list[StageCompleted],
@@ -91,13 +106,19 @@ def _print_completions(
     total: int,
     max_name_width: int,
     stage_logs: dict[str, list[str]] | None = None,
+    stage_warnings: dict[str, _StageWarnings] | None = None,
 ) -> None:
-    """Print buffered completions sorted by index with skip collapsing."""
+    """Print buffered completions sorted by index with skip collapsing.
+
+    A failed stage shows its captured output; any other stage shows the ``WARNING:``
+    lines in ``stage_warnings`` (pass None when those already streamed).
+    """
     if not events:
         return
 
     sorted_events = sorted(events, key=lambda e: e["index"])
     logs = stage_logs or {}
+    warnings_by_stage = stage_warnings or {}
 
     i = 0
     while i < len(sorted_events):
@@ -152,12 +173,53 @@ def _print_completions(
                 if event["reason"]:
                     for detail in _format_error_detail(event["reason"], total=total):
                         console.print(detail)
+            elif event["stage"] in warnings_by_stage:
+                buffered = warnings_by_stage[event["stage"]]
+                stage_lines = [
+                    line if count == 1 else f"{line} (×{count})"
+                    for line, count in buffered.stage.items()
+                ]
+                for warning_line in [*buffered.lossy_outputs, *stage_lines]:
+                    escaped = rich.markup.escape(warning_line)
+                    console.print(f"          [yellow]{escaped}[/yellow]")
+                if buffered.dropped:
+                    console.print(
+                        f"          [yellow]… {buffered.dropped} more warnings "
+                        + "(run with --show-output)[/yellow]"
+                    )
             i += 1
 
 
 _MAX_LOG_LINES_PER_STAGE = 50
 
 
+def _buffer_log_line(
+    event: LogLine,
+    stage_logs: dict[str, list[str]],
+    stage_warnings: dict[str, _StageWarnings],
+) -> None:
+    """Keep a stage's output for a failure report and its warnings for every report.
+
+    Warnings have their own buffer: output writes log them after the stage's own output,
+    which can already fill the log buffer.
+    """
+    line = event["line"]
+    buf = stage_logs.setdefault(event["stage"], [])
+    if len(buf) < _MAX_LOG_LINES_PER_STAGE:
+        buf.append(line)
+    if not line.startswith("WARNING:"):
+        return
+    buffered = stage_warnings.setdefault(event["stage"], _StageWarnings())
+    if LOSSY_OUTPUT_PHRASE in line and line.startswith("WARNING: Stage '"):
+        buffered.lossy_outputs.append(line)
+    elif line in buffered.stage:
+        buffered.stage[line] += 1
+    elif len(buffered.stage) < _MAX_LOG_LINES_PER_STAGE:
+        buffered.stage[line] = 1
+    else:
+        buffered.dropped += 1
+
+
 class StaticConsoleSink:
     """Pipe/CI sink: buffers completions, prints a sorted report when each run ends."""
 
@@ -166,6 +228,7 @@ class StaticConsoleSink:
     _max_name_width: int
     _completion_buffer: list[StageCompleted]
     _stage_logs: dict[str, list[str]]
+    _stage_warnings: dict[str, _StageWarnings]
     _total: int
 
     def __init__(self, *, console: rich.console.Console, show_output: bool = False) -> None:
@@ -174,6 +237,7 @@ class StaticConsoleSink:
         self._max_name_width = 0
         self._completion_buffer = list[StageCompleted]()
         self._stage_logs = dict[str, list[str]]()
+        self._stage_warnings = dict[str, _StageWarnings]()
         self._total = 0
 
     async def handle(self, event: OutputEvent) -> None:
@@ -187,11 +251,9 @@ class StaticConsoleSink:
                 self._max_name_width = max(self._max_name_width, len(event["stage"]))
                 self._completion_buffer.append(event)
             case "log_line":
-                # Always buffer for failed-stage output; stream if --show-output
+                # Buffer for the report; stream if --show-output
                 stage = event["stage"]
-                buf = self._stage_logs.setdefault(stage, [])
-                if len(buf) < _MAX_LOG_LINES_PER_STAGE:
-                    buf.append(event["line"])
+                _buffer_log_line(event, self._stage_logs, self._stage_warnings)
                 if self._show_output:
                     line = rich.markup.escape(event["line"])
                     if event["is_stderr"]:
@@ -218,10 +280,12 @@ class StaticConsoleSink:
             total=self._total,
             max_name_width=self._max_name_width,
             stage_logs=self._stage_logs,
+            stage_warnings=None if self._show_output else self._stage_warnings,
         )
         self._max_name_width = 0
         self._completion_buffer.clear()
         self._stage_logs.clear()
+        self._stage_warnings.clear()
         self._total = 0
 
     async def close(self) -> None:
@@ -254,6 +318,7 @@ class LiveConsoleSink:
     _max_name_width: int
     _completion_buffer: list[StageCompleted]
     _stage_logs: dict[str, list[str]]
+    _stage_warnings: dict[str, _StageWarnings]
     _total: int
     _live: rich.live.Live | None
 
@@ -268,6 +333,7 @@ class LiveConsoleSink:
         self._max_name_width = 0
         self._completion_buffer = list[StageCompleted]()
         self._stage_logs = dict[str, list[str]]()
+        self._stage_warnings = dict[str, _StageWarnings]()
         self._total = 0
         self._live = None
 
@@ -372,9 +438,7 @@ class LiveConsoleSink:
                 self._update_live()
             case "log_line":
                 stage = event["stage"]
-                buf = self._stage_logs.setdefault(stage, [])
-                if len(buf) < _MAX_LOG_LINES_PER_STAGE:
-                    buf.append(event["line"])
+                _buffer_log_line(event, self._stage_logs, self._stage_warnings)
                 if self._show_output:
                     line = rich.markup.escape(event["line"])
                     if event["is_stderr"]:
@@ -405,6 +469,7 @@ class LiveConsoleSink:
             total=self._total,
             max_name_width=self._max_name_width,
             stage_logs=self._stage_logs,
+            stage_warnings=None if self._show_output else self._stage_warnings,
         )
         self._running.clear()
         self._completed_count = 0
@@ -412,6 +477,7 @@ class LiveConsoleSink:
         self._max_name_width = 0
         self._completion_buffer.clear()
         self._stage_logs.clear()
+        self._stage_warnings.clear()
         self._total = 0
 
     async def close(self) -> None:

{pivot-0.2.1 → pivot-0.2.2}/src/pivot/executor/worker.py

@@ -18,6 +18,7 @@ import random
 import sys
 import threading
 import traceback
+import warnings
 from typing import IO, TYPE_CHECKING, Any, Literal, NamedTuple, TypedDict, cast, overload, override
 
 import pydantic
@@ -819,6 +820,42 @@ def _write_output_with_store(
         _reject_path_inside_project(ref, value, project_root, dependency_paths)
     output_path = store.prepare_output(ref)
     writer = cast("Any", ref.format)
+
+    output_label = (
+        f"its {type(writer).__name__} output"
+        if ref.identity.key is None
+        else f"output {ref.identity.key!r}"
+    )
+
+    def save_output(output_value: Any, destination: pathlib.Path) -> None:
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always", loaders.LossyOutputWarning)
+            try:
+                writer.save(output_value, destination)
+            except TypeError as e:
+                if isinstance(writer, loaders.YAML):
+                    raise TypeError(
+                        f"Stage '{ref.identity.producer}' cannot write {output_label}: {e}"
+                    ) from e
+                raise
+        for caught_warning in caught:
+            if issubclass(caught_warning.category, loaders.LossyOutputWarning):
+                logger.warning(
+                    "Stage '%s' wrote %s %s: %s",
+                    ref.identity.producer,
+                    output_label,
+                    types.LOSSY_OUTPUT_PHRASE,
+                    caught_warning.message,
+                )
+            else:
+                warnings.warn_explicit(
+                    caught_warning.message,
+                    caught_warning.category,
+                    caught_warning.filename,
+                    caught_warning.lineno,
+                    source=caught_warning.source,
+                )
+
     if ref.tag is types.ArtifactTag.DIRECTORY:
         if not isinstance(value, dict):
             raise RuntimeError(
@@ -845,11 +882,11 @@ def _write_output_with_store(
             members.append((output_path / normalized, item_value))
         for full_path, item_value in members:
             full_path.parent.mkdir(parents=True, exist_ok=True)
-            writer.save(item_value, full_path)
+            save_output(item_value, full_path)
         return output_path
 
     output_path.parent.mkdir(parents=True, exist_ok=True)
-    writer.save(value, output_path)
+    save_output(value, output_path)
     return output_path