shrinkray 25.12.27.1__py3-none-any.whl → 25.12.27.3__py3-none-any.whl

shrinkray/state.py

@@ -8,9 +8,10 @@ import subprocess
 import sys
 import time
 from abc import ABC, abstractmethod
+from collections import deque
 from datetime import timedelta
 from tempfile import TemporaryDirectory
-from typing import Any
+from typing import Any, TypeVar
 
 import humanize
 import trio
@@ -21,12 +22,15 @@ from shrinkray.problem import (
     BasicReductionProblem,
     InvalidInitialExample,
     ReductionProblem,
-    shortlex,
+    sort_key_for_initial,
 )
 from shrinkray.reducer import DirectoryShrinkRay, Reducer, ShrinkRay
 from shrinkray.work import Volume, WorkContext
 
 
+T = TypeVar("T")
+
+
 class TimeoutExceededOnInitial(InvalidInitialExample):
     def __init__(self, runtime: float, timeout: float) -> None:
         self.runtime = runtime
@@ -55,6 +59,125 @@ def compute_dynamic_timeout(runtime: float) -> float:
     )
 
 
+@define
+class TestOutputManager:
+    """Manages temporary files for test output capture.
+
+    Allocates unique files for each test's stdout/stderr output,
+    tracks active and completed tests, and cleans up old files.
+    """
+
+    output_dir: str
+    max_files: int = 50
+    max_age_seconds: float = 60.0
+    min_display_seconds: float = 1.0  # Minimum time to show completed output
+    grace_period_seconds: float = (
+        0.5  # Extra time to wait for new test after min_display
+    )
+
+    _sequence: int = 0
+    _active_outputs: dict[int, str] = {}
+    _completed_outputs: deque[tuple[int, str, float]] = deque()
+
+    def __attrs_post_init__(self) -> None:
+        # Initialize mutable defaults
+        self._active_outputs = {}
+        self._completed_outputs = deque()
+
+    def allocate_output_file(self) -> tuple[int, str]:
+        """Allocate a new output file for a test. Returns (test_id, file_path)."""
+        test_id = self._sequence
+        self._sequence += 1
+        file_path = os.path.join(self.output_dir, f"test_{test_id}.log")
+        self._active_outputs[test_id] = file_path
+        return test_id, file_path
+
+    def mark_completed(self, test_id: int) -> 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._cleanup_old_files()
+
+    def _cleanup_old_files(self) -> None:
+        """Remove old output files based on count and age limits."""
+        now = time.time()
+        # Remove files older than max_age_seconds
+        while (
+            self._completed_outputs
+            and now - self._completed_outputs[0][2] > self.max_age_seconds
+        ):
+            _, 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()
+            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
+
+        # Show completed test during the full display window
+        if elapsed < self.min_display_seconds + self.grace_period_seconds:
+            return test_id, file_path
+
+        return None
+
+    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 always take priority
+        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)
+        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.
+
+        Returns the active test ID if one is running, None otherwise.
+        """
+        if self._active_outputs:
+            return max(self._active_outputs.keys())
+        return 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:
+            self._safe_delete(file_path)
+        self._active_outputs.clear()
+        self._completed_outputs.clear()
+
+    @staticmethod
+    def _safe_delete(path: str) -> None:
+        try:
+            os.unlink(path)
+        except OSError:
+            pass
+
+
 @define(slots=False)
 class ShrinkRayState[TestCase](ABC):
     input_type: Any  # InputType from __main__
@@ -88,6 +211,9 @@ class ShrinkRayState[TestCase](ABC):
     # Stores the output from the last debug run
     _last_debug_output: str = ""
 
+    # Optional output manager for capturing test output (TUI mode)
+    output_manager: TestOutputManager | None = None
+
     def __attrs_post_init__(self):
         self.is_interesting_limiter = trio.CapacityLimiter(max(self.parallelism, 1))
         self.setup_formatter()
@@ -172,8 +298,17 @@ class ShrinkRayState[TestCase](ABC):
 
             return completed.returncode
 
-        # Check if we should stream output to stderr (volume=debug)
-        if self.volume == Volume.debug:
+        # Determine output handling
+        test_id: int | None = None
+        output_file_handle = None
+
+        if self.output_manager is not None:
+            # Capture output to a file for TUI display
+            test_id, output_path = self.output_manager.allocate_output_file()
+            output_file_handle = open(output_path, "wb")
+            kwargs["stdout"] = output_file_handle.fileno()
+            kwargs["stderr"] = subprocess.STDOUT  # Combine stderr into stdout
+        elif self.volume == Volume.debug:
             # Inherit stderr from parent process to stream output in real-time
             kwargs["stderr"] = None  # None means inherit
             kwargs["stdout"] = subprocess.DEVNULL
@@ -182,59 +317,66 @@ class ShrinkRayState[TestCase](ABC):
             kwargs["stdout"] = subprocess.DEVNULL
             kwargs["stderr"] = subprocess.DEVNULL
 
-        async with trio.open_nursery() as nursery:
-
-            def call_with_kwargs(task_status=trio.TASK_STATUS_IGNORED):  # type: ignore
-                return trio.run_process(command, **kwargs, task_status=task_status)
+        try:
+            async with trio.open_nursery() as nursery:
 
-            start_time = time.time()
-            sp = await nursery.start(call_with_kwargs)
-
-            try:
-                # Determine effective timeout for this call
-                if self.first_call:
-                    # For first call: use calibration timeout if dynamic, otherwise 10x explicit timeout
-                    if self.timeout is None:
-                        effective_timeout = DYNAMIC_TIMEOUT_CALIBRATION_TIMEOUT
-                    else:
-                        effective_timeout = self.timeout * 10
-                else:
-                    # For subsequent calls, timeout must be set (either explicit or computed)
-                    assert self.timeout is not None
-                    effective_timeout = self.timeout
-
-                with trio.move_on_after(effective_timeout):
-                    await sp.wait()
-
-                runtime = time.time() - start_time
-
-                if sp.returncode is None:
-                    # Process didn't terminate before timeout - kill it
-                    await self._interrupt_wait_and_kill(sp)
-
-                # Check for timeout violation (only when timeout is explicitly set)
-                if (
-                    self.timeout is not None
-                    and runtime >= self.timeout
-                    and self.first_call
-                ):
-                    raise TimeoutExceededOnInitial(
-                        timeout=self.timeout,
-                        runtime=runtime,
-                    )
-            finally:
-                if self.first_call:
-                    self.initial_exit_code = sp.returncode
-                    # Set dynamic timeout if not explicitly specified
-                    if self.timeout is None:
-                        runtime = time.time() - start_time
-                        self.timeout = compute_dynamic_timeout(runtime)
-                self.first_call = False
+                def call_with_kwargs(task_status=trio.TASK_STATUS_IGNORED):  # type: ignore
+                    return trio.run_process(command, **kwargs, task_status=task_status)
 
-            result: int | None = sp.returncode
-            assert result is not None
+                start_time = time.time()
+                sp = await nursery.start(call_with_kwargs)
 
-            return result
+                try:
+                    # Determine effective timeout for this call
+                    if self.first_call:
+                        # For first call: use calibration timeout if dynamic, otherwise 10x explicit timeout
+                        if self.timeout is None:
+                            effective_timeout = DYNAMIC_TIMEOUT_CALIBRATION_TIMEOUT
+                        else:
+                            effective_timeout = self.timeout * 10
+                    else:
+                        # For subsequent calls, timeout must be set (either explicit or computed)
+                        assert self.timeout is not None
+                        effective_timeout = self.timeout
+
+                    with trio.move_on_after(effective_timeout):
+                        await sp.wait()
+
+                    runtime = time.time() - start_time
+
+                    if sp.returncode is None:
+                        # Process didn't terminate before timeout - kill it
+                        await self._interrupt_wait_and_kill(sp)
+
+                    # Check for timeout violation (only when timeout is explicitly set)
+                    if (
+                        self.timeout is not None
+                        and runtime >= self.timeout
+                        and self.first_call
+                    ):
+                        raise TimeoutExceededOnInitial(
+                            timeout=self.timeout,
+                            runtime=runtime,
+                        )
+                finally:
+                    if self.first_call:
+                        self.initial_exit_code = sp.returncode
+                        # Set dynamic timeout if not explicitly specified
+                        if self.timeout is None:
+                            runtime = time.time() - start_time
+                            self.timeout = compute_dynamic_timeout(runtime)
+                    self.first_call = False
+
+                result: int | None = sp.returncode
+                assert result is not None
+
+                return result
+        finally:
+            # Clean up output file handle and mark test as completed
+            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)
 
     async def run_for_exit_code(self, test_case: TestCase, debug: bool = False) -> int:
         # Lazy import
@@ -310,6 +452,7 @@ class ShrinkRayState[TestCase](ABC):
             is_interesting=self.is_interesting,
             initial=self.initial,
             work=work,
+            sort_key=sort_key_for_initial(self.initial),
             **self.extra_problem_kwargs,
         )
 
@@ -593,20 +736,9 @@ class ShrinkRayDirectoryState(ShrinkRayState[dict[str, bytes]]):
     def setup_formatter(self): ...
 
     @property
-    def extra_problem_kwargs(self):
-        def dict_size(test_case: dict[str, bytes]) -> int:
-            return sum(len(v) for v in test_case.values())
-
-        def dict_sort_key(test_case: dict[str, bytes]) -> Any:
-            return (
-                len(test_case),
-                dict_size(test_case),
-                sorted((k, shortlex(v)) for k, v in test_case.items()),
-            )
-
+    def extra_problem_kwargs(self) -> dict[str, Any]:
         return {
-            "sort_key": dict_sort_key,
-            "size": dict_size,
+            "size": lambda tc: sum(len(v) for v in tc.values()),
         }
 
     def new_reducer(

shrinkray/subprocess/client.py

@@ -136,6 +136,7 @@ class SubprocessClient:
         no_clang_delta: bool = False,
         clang_delta: str = "",
         trivial_is_error: bool = True,
+        skip_validation: bool = False,
     ) -> Response:
         """Start the reduction process."""
         params: dict[str, Any] = {
@@ -149,6 +150,7 @@ class SubprocessClient:
             "no_clang_delta": no_clang_delta,
             "clang_delta": clang_delta,
             "trivial_is_error": trivial_is_error,
+            "skip_validation": skip_validation,
         }
         if parallelism is not None:
             params["parallelism"] = parallelism

shrinkray/subprocess/protocol.py

@@ -56,6 +56,10 @@ class ProgressUpdate:
     current_pass_name: str = ""
     # List of disabled pass names
     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)
+    active_test_id: int | None = None
 
 
 @dataclass
@@ -115,6 +119,8 @@ def serialize(msg: Request | Response | ProgressUpdate) -> str:
                 ],
                 "current_pass_name": msg.current_pass_name,
                 "disabled_passes": msg.disabled_passes,
+                "test_output_preview": msg.test_output_preview,
+                "active_test_id": msg.active_test_id,
             },
         }
     else:
@@ -162,6 +168,8 @@ def deserialize(line: str) -> Request | Response | ProgressUpdate:
             pass_stats=pass_stats_data,
             current_pass_name=d.get("current_pass_name", ""),
             disabled_passes=d.get("disabled_passes", []),
+            test_output_preview=d.get("test_output_preview", ""),
+            active_test_id=d.get("active_test_id"),
         )
 
     # Check for response (has "result" or "error" field)

shrinkray/subprocess/worker.py

@@ -1,7 +1,9 @@
 """Worker subprocess that runs the reducer with trio and communicates via JSON protocol."""
 
 import os
+import shutil
 import sys
+import tempfile
 import time
 import traceback
 from contextlib import aclosing
@@ -62,6 +64,8 @@ class ReducerWorker:
         # I/O streams - None means use stdin/stdout
         self._input_stream = input_stream
         self._output_stream = output_stream
+        # Output directory for test output capture (cleaned up on shutdown)
+        self._output_dir: str | None = None
 
     async def emit(self, msg: Response | ProgressUpdate) -> None:
         """Write a message to the output stream."""
@@ -163,6 +167,7 @@ class ReducerWorker:
         from shrinkray.state import (
             ShrinkRayDirectoryState,
             ShrinkRayStateSingleFile,
+            TestOutputManager,
         )
         from shrinkray.work import Volume
 
@@ -178,6 +183,7 @@ class ReducerWorker:
         no_clang_delta = params.get("no_clang_delta", False)
         clang_delta_path = params.get("clang_delta", "")
         trivial_is_error = params.get("trivial_is_error", True)
+        skip_validation = params.get("skip_validation", False)
 
         clang_delta_executable = None
         if os.path.splitext(filename)[1] in C_FILE_EXTENSIONS and not no_clang_delta:
@@ -213,12 +219,18 @@ class ReducerWorker:
                 initial = reader.read()
             self.state = ShrinkRayStateSingleFile(initial=initial, **state_kwargs)
 
+        # 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.problem = self.state.problem
         self.reducer = self.state.reducer
 
         # Validate initial example before starting - this will raise
-        # InvalidInitialExample if the initial test case fails
-        await self.problem.setup()
+        # InvalidInitialExample if the initial test case fails.
+        # Skip if validation was already done by the caller (e.g., main()).
+        if not skip_validation:
+            await self.problem.setup()
 
         self.running = True
 
@@ -300,6 +312,32 @@ 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."""
+        if self.state is None or self.state.output_manager is None:
+            return "", None
+
+        manager = self.state.output_manager
+        active_test_id = manager.get_active_test_id()
+        output_path = manager.get_current_output_path()
+
+        if output_path is None:
+            return "", active_test_id
+
+        # Read last 4KB of file
+        try:
+            with open(output_path, "rb") as f:
+                f.seek(0, 2)  # Seek to end
+                size = f.tell()
+                if size > 4096:
+                    f.seek(-4096, 2)
+                else:
+                    f.seek(0)
+                data = f.read()
+            return data.decode("utf-8", errors="replace"), active_test_id
+        except OSError:
+            return "", active_test_id
+
     def _get_content_preview(self) -> tuple[str, bool]:
         """Get a preview of the current test case content."""
         if self.problem is None:
@@ -402,6 +440,9 @@ class ReducerWorker:
         else:
             disabled_passes = []
 
+        # Get test output preview
+        test_output_preview, active_test_id = self._get_test_output_preview()
+
         return ProgressUpdate(
             status=self.reducer.status if self.reducer else "",
             size=stats.current_test_case_size,
@@ -420,6 +461,8 @@ class ReducerWorker:
             pass_stats=pass_stats_list,
             current_pass_name=current_pass_name,
             disabled_passes=disabled_passes,
+            test_output_preview=test_output_preview,
+            active_test_id=active_test_id,
         )
 
     async def emit_progress_updates(self) -> None:
@@ -469,25 +512,32 @@ class ReducerWorker:
 
     async def run(self) -> None:
         """Main entry point for the worker."""
-        async with trio.open_nursery() as nursery:
-            await nursery.start(self.read_commands)
+        try:
+            async with trio.open_nursery() as nursery:
+                await nursery.start(self.read_commands)
 
-            # Wait for start command
-            while not self.running:
-                await trio.sleep(0.01)
+                # Wait for start command
+                while not self.running:
+                    await trio.sleep(0.01)
 
-            # Start progress updates and reducer
-            nursery.start_soon(self.emit_progress_updates)
-            await self.run_reducer()
+                # Start progress updates and reducer
+                nursery.start_soon(self.emit_progress_updates)
+                await self.run_reducer()
 
-            # Emit final progress update before completion
-            final_update = await self._build_progress_update()
-            if final_update is not None:
-                await self.emit(final_update)
+                # Emit final progress update before completion
+                final_update = await self._build_progress_update()
+                if final_update is not None:
+                    await self.emit(final_update)
 
-            # Signal completion
-            await self.emit(Response(id="", result={"status": "completed"}))
-            nursery.cancel_scope.cancel()
+                # Signal completion
+                await self.emit(Response(id="", result={"status": "completed"}))
+                nursery.cancel_scope.cancel()
+        finally:
+            # Clean up test output files and temp directory
+            if self.state is not None and self.state.output_manager is not None:
+                self.state.output_manager.cleanup_all()
+            if self._output_dir is not None and os.path.isdir(self._output_dir):
+                shutil.rmtree(self._output_dir, ignore_errors=True)
 
 
 def main() -> None: