shrinkray 25.12.28.0__tar.gz → 25.12.29.0__tar.gz

{shrinkray-25.12.28.0/src/shrinkray.egg-info → shrinkray-25.12.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.28.0
+Version: 25.12.29.0
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
@@ -16,6 +16,7 @@ Requires-Dist: click>=8.0.1
 Requires-Dist: chardet>=5.2.0
 Requires-Dist: trio>=0.28.0
 Requires-Dist: textual>=0.47.0
+Requires-Dist: textual-plotext>=0.2.0
 Requires-Dist: humanize>=4.9.0
 Requires-Dist: libcst>=1.1.0
 Requires-Dist: exceptiongroup>=1.2.0
@@ -28,6 +29,8 @@ Requires-Dist: hypothesmith>=0.3.1; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-trio>=0.8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
 Requires-Dist: syrupy>=5.0.0; extra == "dev"
 Requires-Dist: jinja2>=3.0.0; extra == "dev"
 Requires-Dist: coverage[toml]>=7.4.0; extra == "dev"
@@ -78,7 +81,12 @@ shrinkray (or any other test-case reducer) then systematically tries smaller and
 
 While it runs, you will see the following user interface:
 
-![Demo of shrink ray running](demo.png)
+<video controls poster="gallery/enterprise-hello/hello.png">
+  <source src="https://drmaciver.github.io/shrinkray/assets/hello.mp4" type="video/mp4">
+  Your browser doesn't support video. <a href="gallery/enterprise-hello/hello.gif">View the GIF instead</a>.
+</video>
+
+(This is a toy example based on reducing a ridiculously bad version of hello world)
 
 When it finishes you will be left with the reduced test case in `mytestcase.py`.
 

{shrinkray-25.12.28.0 → shrinkray-25.12.29.0}/README.md

@@ -38,7 +38,12 @@ shrinkray (or any other test-case reducer) then systematically tries smaller and
 
 While it runs, you will see the following user interface:
 
-![Demo of shrink ray running](demo.png)
+<video controls poster="gallery/enterprise-hello/hello.png">
+  <source src="https://drmaciver.github.io/shrinkray/assets/hello.mp4" type="video/mp4">
+  Your browser doesn't support video. <a href="gallery/enterprise-hello/hello.gif">View the GIF instead</a>.
+</video>
+
+(This is a toy example based on reducing a ridiculously bad version of hello world)
 
 When it finishes you will be left with the reduced test case in `mytestcase.py`.
 

{shrinkray-25.12.28.0 → shrinkray-25.12.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "25.12.28.0"
+version = "25.12.29.0"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}
@@ -16,6 +16,7 @@ dependencies = [
     "chardet>=5.2.0",
     "trio>=0.28.0",
     "textual>=0.47.0",
+    "textual-plotext>=0.2.0",
     "humanize>=4.9.0",
     "libcst>=1.1.0",
     "exceptiongroup>=1.2.0",
@@ -41,6 +42,8 @@ dev = [
     "pytest>=8.0.0",
     "pytest-trio>=0.8.0",
     "pytest-asyncio>=0.21.0",
+    "pytest-xdist>=3.5.0",
+    "pytest-cov>=4.1.0",
     # pytest-textual-snapshot is vendored in tests/pytest_textual_snapshot.py
     # to fix syrupy 5.0 compatibility. These are its dependencies:
     "syrupy>=5.0.0",
@@ -67,7 +70,7 @@ core = "ctrace"
 
 [tool.coverage.report]
 show_missing = true
-fail_under = 100
+# fail_under is enforced in justfile to allow split parallel/serial runs
 
 [tool.ruff]
 line-length = 88

{shrinkray-25.12.28.0 → shrinkray-25.12.29.0}/src/shrinkray/state.py

@@ -57,7 +57,7 @@ def compute_dynamic_timeout(runtime: float) -> float:
 
 
 @define
-class TestOutputManager:
+class OutputCaptureManager:
     """Manages temporary files for test output capture.
 
     Allocates unique files for each test's stdout/stderr output,
@@ -74,7 +74,8 @@ class TestOutputManager:
 
     _sequence: int = 0
     _active_outputs: dict[int, str] = {}
-    _completed_outputs: deque[tuple[int, str, float]] = deque()
+    # Completed outputs: (test_id, file_path, completion_time, return_code)
+    _completed_outputs: deque[tuple[int, str, float, int]] = deque()
 
     def __attrs_post_init__(self) -> None:
         # Initialize mutable defaults
@@ -89,11 +90,13 @@ class TestOutputManager:
         self._active_outputs[test_id] = file_path
         return test_id, file_path
 
-    def mark_completed(self, test_id: int) -> None:
+    def mark_completed(self, test_id: int, return_code: int = 0) -> None:
         """Mark a test as completed and move to completed queue."""
         if test_id in self._active_outputs:
             file_path = self._active_outputs.pop(test_id)
-            self._completed_outputs.append((test_id, file_path, time.time()))
+            self._completed_outputs.append(
+                (test_id, file_path, time.time(), return_code)
+            )
             self._cleanup_old_files()
 
     def _cleanup_old_files(self) -> None:
@@ -104,65 +107,55 @@ class TestOutputManager:
             self._completed_outputs
             and now - self._completed_outputs[0][2] > self.max_age_seconds
         ):
-            _, file_path, _ = self._completed_outputs.popleft()
+            _, file_path, _, _ = self._completed_outputs.popleft()
             self._safe_delete(file_path)
         # Remove excess files beyond max_files
         while len(self._completed_outputs) > self.max_files:
-            _, file_path, _ = self._completed_outputs.popleft()
+            _, file_path, _, _ = self._completed_outputs.popleft()
             self._safe_delete(file_path)
 
-    def _should_show_completed(self) -> tuple[int, str] | None:
-        """Check if we should show a completed test's output.
-
-        Note: This method is only called when there are no active tests.
-        It returns the completed test info if within the display window
-        (min_display_seconds + grace_period).
-        """
-        if not self._completed_outputs:
-            return None
-        test_id, file_path, completion_time = self._completed_outputs[-1]
-        elapsed = time.time() - completion_time
+    @staticmethod
+    def _file_has_content(path: str) -> bool:
+        """Check if a file exists and has non-zero size."""
+        try:
+            return os.path.getsize(path) > 0
+        except OSError:
+            return False
 
-        # Show completed test during the full display window
-        if elapsed < self.min_display_seconds + self.grace_period_seconds:
-            return test_id, file_path
+    def get_current_output(self) -> tuple[str | None, int | None, int | None]:
+        """Get the current output to display.
 
-        return None
+        Returns (file_path, test_id, return_code) where:
+        - file_path: path to the output file to display
+        - test_id: the test ID (for display in header)
+        - return_code: the return code (None if test is still running)
 
-    def get_current_output_path(self) -> str | None:
-        """Get the most relevant output file path.
-
-        Active tests always take priority. If no active test, shows
-        recently completed test output for min_display_seconds, plus
-        an additional grace_period if no new test has started.
+        Active tests take priority only if they have produced output.
+        Otherwise, shows recently completed test output for min_display_seconds,
+        plus an additional grace_period if no new test has started.
         """
-        # Active tests always take priority
+        # Active tests take priority only if they have content
         if self._active_outputs:
             max_id = max(self._active_outputs.keys())
-            return self._active_outputs[max_id]
-        # Then check for recently completed test that should stay visible
-        recent = self._should_show_completed()
-        if recent is not None:
-            return recent[1]
-        # Fall back to most recent completed (even if past display window)
+            active_path = self._active_outputs[max_id]
+            if self._file_has_content(active_path):
+                # Active test with output - no return code yet
+                return active_path, max_id, None
+            # Active test has no output yet - fall through to show previous output
+
+        # Check for recently completed test that should stay visible,
+        # or fall back to most recent completed (even if past display window)
         if self._completed_outputs:
-            return self._completed_outputs[-1][1]
-        return None
-
-    def get_active_test_id(self) -> int | None:
-        """Get the currently running test ID, if any.
+            test_id, file_path, _, return_code = self._completed_outputs[-1]
+            return file_path, test_id, return_code
 
-        Returns the active test ID if one is running, None otherwise.
-        """
-        if self._active_outputs:
-            return max(self._active_outputs.keys())
-        return None
+        return None, None, None
 
     def cleanup_all(self) -> None:
         """Clean up all output files (called on shutdown)."""
         for file_path in self._active_outputs.values():
             self._safe_delete(file_path)
-        for _, file_path, _ in self._completed_outputs:
+        for _, file_path, _, _ in self._completed_outputs:
             self._safe_delete(file_path)
         self._active_outputs.clear()
         self._completed_outputs.clear()
@@ -209,7 +202,7 @@ class ShrinkRayState[TestCase](ABC):
     _last_debug_output: str = ""
 
     # Optional output manager for capturing test output (TUI mode)
-    output_manager: TestOutputManager | None = None
+    output_manager: OutputCaptureManager | None = None
 
     def __attrs_post_init__(self):
         self.is_interesting_limiter = trio.CapacityLimiter(max(self.parallelism, 1))
@@ -298,6 +291,7 @@ class ShrinkRayState[TestCase](ABC):
         # Determine output handling
         test_id: int | None = None
         output_file_handle = None
+        exit_code: int | None = None  # Track for output manager
 
         if self.output_manager is not None:
             # Capture output to a file for TUI display
@@ -366,6 +360,7 @@ class ShrinkRayState[TestCase](ABC):
 
                 result: int | None = sp.returncode
                 assert result is not None
+                exit_code = result
 
                 return result
         finally:
@@ -373,7 +368,7 @@ class ShrinkRayState[TestCase](ABC):
             if output_file_handle is not None:
                 output_file_handle.close()
             if test_id is not None and self.output_manager is not None:
-                self.output_manager.mark_completed(test_id)
+                self.output_manager.mark_completed(test_id, exit_code or 0)
 
     async def run_for_exit_code(self, test_case: TestCase, debug: bool = False) -> int:
         # Lazy import

{shrinkray-25.12.28.0 → shrinkray-25.12.29.0}/src/shrinkray/subprocess/protocol.py

@@ -57,8 +57,13 @@ class ProgressUpdate:
     disabled_passes: list[str] = field(default_factory=list)
     # Test output preview (last 4KB of current/recent test output)
     test_output_preview: str = ""
-    # Currently running test ID (None if no test running)
+    # Test ID of the output being displayed (None if no output yet)
     active_test_id: int | None = None
+    # Return code of the displayed test (None if test is still running)
+    last_test_return_code: int | None = None
+    # New size history entries since last update: list of (runtime_seconds, size)
+    # Client should accumulate these over time
+    new_size_history: list[tuple[float, int]] = field(default_factory=list)
 
 
 @dataclass
@@ -120,6 +125,8 @@ def serialize(msg: Request | Response | ProgressUpdate) -> str:
                 "disabled_passes": msg.disabled_passes,
                 "test_output_preview": msg.test_output_preview,
                 "active_test_id": msg.active_test_id,
+                "last_test_return_code": msg.last_test_return_code,
+                "new_size_history": msg.new_size_history,
             },
         }
     else:
@@ -169,6 +176,8 @@ def deserialize(line: str) -> Request | Response | ProgressUpdate:
             disabled_passes=d.get("disabled_passes", []),
             test_output_preview=d.get("test_output_preview", ""),
             active_test_id=d.get("active_test_id"),
+            last_test_return_code=d.get("last_test_return_code"),
+            new_size_history=[tuple(x) for x in d.get("new_size_history", [])],
         )
 
     # Check for response (has "result" or "error" field)

{shrinkray-25.12.28.0 → shrinkray-25.12.29.0}/src/shrinkray/subprocess/worker.py

@@ -58,6 +58,11 @@ class ReducerWorker:
         self._output_stream = output_stream
         # Output directory for test output capture (cleaned up on shutdown)
         self._output_dir: str | None = None
+        # Size history for graphing: list of (runtime_seconds, size) tuples
+        self._size_history: list[tuple[float, int]] = []
+        self._last_sent_history_index: int = 0
+        self._last_recorded_size: int = 0
+        self._last_history_time: float = 0.0
 
     async def emit(self, msg: Response | ProgressUpdate) -> None:
         """Write a message to the output stream."""
@@ -157,9 +162,9 @@ class ReducerWorker:
             find_clang_delta,
         )
         from shrinkray.state import (
+            OutputCaptureManager,
             ShrinkRayDirectoryState,
             ShrinkRayStateSingleFile,
-            TestOutputManager,
         )
         from shrinkray.work import Volume
 
@@ -213,7 +218,7 @@ class ReducerWorker:
 
         # Create output manager for test output capture (always enabled for TUI)
         self._output_dir = tempfile.mkdtemp(prefix="shrinkray-output-")
-        self.state.output_manager = TestOutputManager(output_dir=self._output_dir)
+        self.state.output_manager = OutputCaptureManager(output_dir=self._output_dir)
 
         self.problem = self.state.problem
         self.reducer = self.state.reducer
@@ -304,17 +309,23 @@ class ReducerWorker:
             return Response(id=request_id, result={"status": "skipped"})
         return Response(id=request_id, error="Reducer does not support pass control")
 
-    def _get_test_output_preview(self) -> tuple[str, int | None]:
-        """Get preview of current test output and active test ID."""
+    def _get_test_output_preview(self) -> tuple[str, int | None, int | None]:
+        """Get preview of current test output, test ID, and return code.
+
+        Returns (content, test_id, return_code) where:
+        - content: the last 4KB of the output file
+        - test_id: the test ID being displayed
+        - return_code: None if test is still running, otherwise the exit code
+        """
         if self.state is None or self.state.output_manager is None:
-            return "", None
+            return "", None, None
 
-        manager = self.state.output_manager
-        active_test_id = manager.get_active_test_id()
-        output_path = manager.get_current_output_path()
+        output_path, test_id, return_code = (
+            self.state.output_manager.get_current_output()
+        )
 
         if output_path is None:
-            return "", active_test_id
+            return "", None, None
 
         # Read last 4KB of file
         try:
@@ -326,9 +337,13 @@ class ReducerWorker:
                 else:
                     f.seek(0)
                 data = f.read()
-            return data.decode("utf-8", errors="replace"), active_test_id
+            return (
+                data.decode("utf-8", errors="replace"),
+                test_id,
+                return_code,
+            )
         except OSError:
-            return "", active_test_id
+            return "", test_id, return_code
 
     def _get_content_preview(self) -> tuple[str, bool]:
         """Get a preview of the current test case content."""
@@ -379,6 +394,29 @@ class ReducerWorker:
             return None
 
         stats = self.problem.stats
+        runtime = time.time() - stats.start_time
+        current_size = stats.current_test_case_size
+
+        # Record size history when size changes or periodically
+        # Use 200ms interval for first 5 minutes, then 1s (ticks are at 1-minute intervals)
+        history_interval = 1.0 if runtime >= 300 else 0.2
+
+        if not self._size_history:
+            # First sample: record initial size at time 0
+            self._size_history.append((0.0, stats.initial_test_case_size))
+            self._last_recorded_size = stats.initial_test_case_size
+            self._last_history_time = 0.0
+
+        if current_size != self._last_recorded_size:
+            # Size changed - always record
+            self._size_history.append((runtime, current_size))
+            self._last_recorded_size = current_size
+            self._last_history_time = runtime
+        elif runtime - self._last_history_time >= history_interval:
+            # No size change but interval passed - record periodic update
+            self._size_history.append((runtime, current_size))
+            self._last_history_time = runtime
+
         content_preview, hex_mode = self._get_content_preview()
 
         # Get parallel workers count and track average
@@ -433,7 +471,13 @@ class ReducerWorker:
             disabled_passes = []
 
         # Get test output preview
-        test_output_preview, active_test_id = self._get_test_output_preview()
+        test_output_preview, active_test_id, last_return_code = (
+            self._get_test_output_preview()
+        )
+
+        # Get new size history entries since last update
+        new_entries = self._size_history[self._last_sent_history_index :]
+        self._last_sent_history_index = len(self._size_history)
 
         return ProgressUpdate(
             status=self.reducer.status if self.reducer else "",
@@ -443,7 +487,7 @@ class ReducerWorker:
             reductions=stats.reductions,
             interesting_calls=stats.interesting_calls,
             wasted_calls=stats.wasted_interesting_calls,
-            runtime=time.time() - stats.start_time,
+            runtime=runtime,
             parallel_workers=parallel_workers,
             average_parallelism=average_parallelism,
             effective_parallelism=effective_parallelism,
@@ -455,6 +499,8 @@ class ReducerWorker:
             disabled_passes=disabled_passes,
             test_output_preview=test_output_preview,
             active_test_id=active_test_id,
+            last_test_return_code=last_return_code,
+            new_size_history=new_entries,
         )
 
     async def emit_progress_updates(self) -> None: