shrinkray 25.12.27.0__tar.gz → 25.12.27.1__tar.gz

{shrinkray-25.12.27.0/src/shrinkray.egg-info → shrinkray-25.12.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.27.0
+Version: 25.12.27.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
@@ -28,7 +28,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-textual-snapshot>=1.0.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"
 Requires-Dist: pygments>=2.17.0; extra == "dev"
 Requires-Dist: basedpyright>=1.1.0; extra == "dev"

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "25.12.27.0"
+version = "25.12.27.1"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}
@@ -41,7 +41,10 @@ dev = [
     "pytest>=8.0.0",
     "pytest-trio>=0.8.0",
     "pytest-asyncio>=0.21.0",
-    "pytest-textual-snapshot>=1.0.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",
+    "jinja2>=3.0.0",
     "coverage[toml]>=7.4.0",
     "pygments>=2.17.0",
     "basedpyright>=1.1.0",

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/src/shrinkray/__main__.py

@@ -75,12 +75,14 @@ async def run_shrink_ray(
 )
 @click.option(
     "--timeout",
-    default=1,
+    default=None,
     type=click.FLOAT,
     help=(
-        "Time out subprocesses after this many seconds. If set to <= 0 then "
-        "no timeout will be used. Any commands that time out will be treated "
-        "as failing the test"
+        "Time out subprocesses after this many seconds. If not specified, "
+        "runs the interestingness test once and sets timeout to 10x the "
+        "measured time (capped at 5 minutes). If set to <= 0 then no timeout "
+        "will be used. Any commands that time out will be treated as failing "
+        "the test"
     ),
 )
 @click.option(
@@ -212,7 +214,7 @@ def main(
     backup: str,
     filename: str,
     test: list[str],
-    timeout: float,
+    timeout: float | None,
     in_place: bool,
     parallelism: int,
     seed: int,
@@ -225,7 +227,7 @@ def main(
     ui_type: UIType,
     theme: str,
 ) -> None:
-    if timeout <= 0:
+    if timeout is not None and timeout <= 0:
         timeout = float("inf")
 
     if not os.access(test[0], os.X_OK):

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/src/shrinkray/state.py

@@ -36,13 +36,32 @@ class TimeoutExceededOnInitial(InvalidInitialExample):
         )
 
 
+# Constants for dynamic timeout
+DYNAMIC_TIMEOUT_CALIBRATION_TIMEOUT = 300.0  # 5 minutes for first call
+DYNAMIC_TIMEOUT_MULTIPLIER = 10
+DYNAMIC_TIMEOUT_MAX = 300.0  # 5 minutes maximum
+DYNAMIC_TIMEOUT_MIN = 1.0  # 1 second minimum to prevent edge cases
+
+
+def compute_dynamic_timeout(runtime: float) -> float:
+    """Compute dynamic timeout based on measured runtime.
+
+    The timeout is set to 10x the measured runtime, clamped between
+    DYNAMIC_TIMEOUT_MIN and DYNAMIC_TIMEOUT_MAX.
+    """
+    return max(
+        DYNAMIC_TIMEOUT_MIN,
+        min(runtime * DYNAMIC_TIMEOUT_MULTIPLIER, DYNAMIC_TIMEOUT_MAX),
+    )
+
+
 @define(slots=False)
 class ShrinkRayState[TestCase](ABC):
     input_type: Any  # InputType from __main__
     in_place: bool
     test: list[str]
     filename: str
-    timeout: float
+    timeout: float | None
     base: str
     parallelism: int
     initial: TestCase
@@ -127,7 +146,8 @@ class ShrinkRayState[TestCase](ABC):
             completed = await trio.run_process(command, **kwargs)
             runtime = time.time() - start_time
 
-            if runtime >= self.timeout and self.first_call:
+            # Check for timeout violation (only when timeout is explicitly set)
+            if self.timeout is not None and runtime >= self.timeout and self.first_call:
                 self.initial_exit_code = completed.returncode
                 self.first_call = False
                 raise TimeoutExceededOnInitial(
@@ -137,6 +157,9 @@ class ShrinkRayState[TestCase](ABC):
 
             if self.first_call:
                 self.initial_exit_code = completed.returncode
+                # Set dynamic timeout if not explicitly specified
+                if self.timeout is None:
+                    self.timeout = compute_dynamic_timeout(runtime)
             self.first_call = False
 
             # Store captured output
@@ -168,9 +191,19 @@ class ShrinkRayState[TestCase](ABC):
             sp = await nursery.start(call_with_kwargs)
 
             try:
-                with trio.move_on_after(
-                    self.timeout * 10 if self.first_call else self.timeout
-                ):
+                # 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
@@ -179,7 +212,12 @@ class ShrinkRayState[TestCase](ABC):
                     # Process didn't terminate before timeout - kill it
                     await self._interrupt_wait_and_kill(sp)
 
-                if runtime >= self.timeout and self.first_call:
+                # 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,
@@ -187,6 +225,10 @@ class ShrinkRayState[TestCase](ABC):
             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

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/src/shrinkray/subprocess/client.py

@@ -127,7 +127,7 @@ class SubprocessClient:
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,
@@ -138,10 +138,9 @@ class SubprocessClient:
         trivial_is_error: bool = True,
     ) -> Response:
         """Start the reduction process."""
-        params = {
+        params: dict[str, Any] = {
             "file_path": file_path,
             "test": test,
-            "timeout": timeout,
             "seed": seed,
             "input_type": input_type,
             "in_place": in_place,
@@ -153,6 +152,8 @@ class SubprocessClient:
         }
         if parallelism is not None:
             params["parallelism"] = parallelism
+        if timeout is not None:
+            params["timeout"] = timeout
         return await self.send_command("start", params)
 
     async def get_status(self) -> Response:

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/src/shrinkray/subprocess/worker.py

@@ -169,7 +169,7 @@ class ReducerWorker:
         filename = params["file_path"]
         test = params["test"]
         parallelism = params.get("parallelism", os.cpu_count() or 1)
-        timeout = params.get("timeout", 1.0)
+        timeout = params.get("timeout")  # None means dynamic timeout
         seed = params.get("seed", 0)
         input_type = InputType[params.get("input_type", "all")]
         in_place = params.get("in_place", False)

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/src/shrinkray/tui.py

@@ -98,7 +98,7 @@ class ReductionClientProtocol(Protocol):
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,
@@ -616,7 +616,7 @@ class ShrinkRayApp(App[None]):
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,
@@ -657,6 +657,7 @@ class ShrinkRayApp(App[None]):
             yield Label(
                 "Shrink Ray - [h] help, [p] passes, [c] skip pass, [q] quit",
                 id="status-label",
+                markup=False,
             )
             with Vertical(id="stats-container"):
                 yield StatsDisplay(id="stats-display")
@@ -807,7 +808,7 @@ async def _validate_initial_example(
     file_path: str,
     test: list[str],
     parallelism: int | None,
-    timeout: float,
+    timeout: float | None,
     seed: int,
     input_type: str,
     in_place: bool,
@@ -855,7 +856,7 @@ def run_textual_ui(
     file_path: str,
     test: list[str],
     parallelism: int | None = None,
-    timeout: float = 1.0,
+    timeout: float | None = None,
     seed: int = 0,
     input_type: str = "all",
     in_place: bool = False,

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1/src/shrinkray.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.27.0
+Version: 25.12.27.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
@@ -28,7 +28,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-textual-snapshot>=1.0.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"
 Requires-Dist: pygments>=2.17.0; extra == "dev"
 Requires-Dist: basedpyright>=1.1.0; extra == "dev"

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/src/shrinkray.egg-info/requires.txt

@@ -15,7 +15,8 @@ hypothesmith>=0.3.1
 pytest>=8.0.0
 pytest-trio>=0.8.0
 pytest-asyncio>=0.21.0
-pytest-textual-snapshot>=1.0.0
+syrupy>=5.0.0
+jinja2>=3.0.0
 coverage[toml]>=7.4.0
 pygments>=2.17.0
 basedpyright>=1.1.0

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/tests/test_state.py

@@ -9,6 +9,7 @@ import trio
 from shrinkray.cli import InputType
 from shrinkray.problem import InvalidInitialExample
 from shrinkray.state import (
+    DYNAMIC_TIMEOUT_MIN,
     ShrinkRayDirectoryState,
     ShrinkRayStateSingleFile,
     TimeoutExceededOnInitial,
@@ -1640,6 +1641,87 @@ async def test_run_for_exit_code_debug_mode_timeout_on_first_call(tmp_path):
     assert state.first_call is False
 
 
+async def test_run_for_exit_code_debug_mode_dynamic_timeout(tmp_path):
+    """Test dynamic timeout computation in debug mode on first call.
+
+    Exercises the dynamic timeout computation path in debug mode.
+    """
+    script = tmp_path / "test.sh"
+    script.write_text("#!/bin/bash\nexit 0")
+    script.chmod(0o755)
+
+    target = tmp_path / "test.txt"
+    target.write_text("hello")
+
+    state = ShrinkRayStateSingleFile(
+        input_type=InputType.arg,
+        in_place=False,
+        test=[str(script)],
+        filename=str(target),
+        timeout=None,  # Dynamic timeout
+        base="test.txt",
+        parallelism=1,
+        initial=b"hello",
+        formatter="none",
+        trivial_is_error=True,
+        seed=0,
+        volume=Volume.quiet,
+        clang_delta_executable=None,
+    )
+
+    # First call in debug mode with None timeout should compute dynamic timeout
+    assert state.timeout is None
+    exit_code = await state.run_for_exit_code(b"hello", debug=True)
+    assert exit_code == 0
+    # After first call, timeout should be computed
+    assert state.timeout is not None
+    assert state.timeout > 0
+    # first_call should be False after this
+    assert state.first_call is False
+
+
+async def test_run_for_exit_code_dynamic_timeout_non_debug(tmp_path):
+    """Test dynamic timeout computation in non-debug mode on first call.
+
+    Exercises the dynamic timeout computation path in non-debug mode,
+    which uses run_script_on_file instead of the debug path.
+    """
+    script = tmp_path / "test.sh"
+    script.write_text("#!/bin/bash\nexit 0")
+    script.chmod(0o755)
+
+    target = tmp_path / "test.txt"
+    target.write_text("hello")
+
+    state = ShrinkRayStateSingleFile(
+        input_type=InputType.arg,
+        in_place=False,
+        test=[str(script)],
+        filename=str(target),
+        timeout=None,  # Dynamic timeout
+        base="test.txt",
+        parallelism=1,
+        initial=b"hello",
+        formatter="none",
+        trivial_is_error=True,
+        seed=0,
+        volume=Volume.quiet,
+        clang_delta_executable=None,
+    )
+
+    # First call in non-debug mode with None timeout should compute dynamic timeout
+    assert state.timeout is None
+    exit_code = await state.run_for_exit_code(b"hello", debug=False)
+    assert exit_code == 0
+    # After first call, timeout should be computed
+    assert state.timeout is not None
+    assert state.timeout > 0
+    # Verify minimum timeout is respected
+    assert state.timeout >= DYNAMIC_TIMEOUT_MIN
+    # first_call should be False after this
+    assert state.first_call is False
+
+
 async def test_run_for_exit_code_debug_mode_captures_stdout(tmp_path):
     """Test that debug mode captures stdout output.
 

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/tests/test_tui.py

@@ -55,7 +55,7 @@ class FakeReductionClient:
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,

{shrinkray-25.12.27.0 → shrinkray-25.12.27.1}/tests/test_tui_snapshots.py

@@ -1,9 +1,33 @@
 """Snapshot tests for the textual TUI."""
 
+import asyncio
+from pathlib import Path
+
 import pytest
 
-from shrinkray.subprocess.protocol import PassStatsData, ProgressUpdate
-from shrinkray.tui import ShrinkRayApp
+from shrinkray.subprocess.protocol import PassStatsData, ProgressUpdate, Response
+from shrinkray.tui import ShrinkRayApp, StatsDisplay
+
+
+# Directory where snapshots are stored
+SNAPSHOTS_DIR = Path(__file__).parent / "__snapshots__" / "test_tui_snapshots"
+
+
+def pytest_sessionfinish(session, exitstatus):
+    """Verify all snapshots contain expected content after tests complete."""
+    if not SNAPSHOTS_DIR.exists():
+        return
+
+    # Using vendored pytest_textual_snapshot with syrupy 5.0 compatibility
+    for snapshot_file in SNAPSHOTS_DIR.glob("*.svg"):
+        content = snapshot_file.read_text()
+        # Each snapshot should contain "Reducer" which appears in StatsDisplay
+        # Note: SVG uses   for non-breaking spaces, so we just check for "Reducer"
+        if "Reducer" not in content:
+            raise AssertionError(
+                f"Snapshot {snapshot_file.name} does not contain expected text 'Reducer'. "
+                "The snapshot may have been captured before the app fully rendered."
+            )
 
 
 class FakeReductionClientForSnapshots:
@@ -12,7 +36,8 @@ class FakeReductionClientForSnapshots:
     def __init__(self, updates: list[ProgressUpdate]):
         self._updates = updates
         self._update_index = 0
-        self._completed = False
+        self._cancelled = False
+        self._updates_consumed = False
 
     async def start(self) -> None:
         pass
@@ -22,7 +47,7 @@ class FakeReductionClientForSnapshots:
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,
@@ -31,34 +56,24 @@ class FakeReductionClientForSnapshots:
         no_clang_delta: bool = False,
         clang_delta: str = "",
         trivial_is_error: bool = True,
-    ):
-        from shrinkray.subprocess.protocol import Response
-
+    ) -> Response:
         return Response(id="start", result={"status": "started"})
 
-    async def cancel(self):
-        from shrinkray.subprocess.protocol import Response
-
-        self._completed = True
+    async def cancel(self) -> Response:
+        self._cancelled = True
         return Response(id="cancel", result={"status": "cancelled"})
 
-    async def disable_pass(self, pass_name: str):
-        from shrinkray.subprocess.protocol import Response
-
+    async def disable_pass(self, pass_name: str) -> Response:
         return Response(
             id="disable", result={"status": "disabled", "pass_name": pass_name}
         )
 
-    async def enable_pass(self, pass_name: str):
-        from shrinkray.subprocess.protocol import Response
-
+    async def enable_pass(self, pass_name: str) -> Response:
         return Response(
             id="enable", result={"status": "enabled", "pass_name": pass_name}
         )
 
-    async def skip_current_pass(self):
-        from shrinkray.subprocess.protocol import Response
-
+    async def skip_current_pass(self) -> Response:
         return Response(id="skip", result={"status": "skipped"})
 
     async def close(self) -> None:
@@ -66,14 +81,18 @@ class FakeReductionClientForSnapshots:
 
     async def get_progress_updates(self):
         for update in self._updates:
-            if self._completed:
+            if self._cancelled:
                 break
             yield update
-        self._completed = True
+        self._updates_consumed = True
+        # Keep the app running by waiting indefinitely (until cancelled)
+        while not self._cancelled:
+            await asyncio.sleep(1)
 
     @property
     def is_completed(self) -> bool:
-        return self._completed
+        # Only complete when cancelled, not when updates are consumed
+        return self._cancelled
 
     @property
     def error_message(self) -> str | None:
@@ -180,40 +199,63 @@ def large_file_update() -> ProgressUpdate:
 # === TUI snapshot tests ===
 
 
+async def wait_for_render(pilot):
+    """Wait for the app to fully render with actual content.
+
+    Checks that the StatsDisplay has received and rendered the update
+    by verifying original_size is non-zero (all test fixtures have non-zero size).
+    """
+    max_attempts = 50  # Generous limit to avoid flakiness
+    for _ in range(max_attempts):
+        await pilot.pause()
+        stats = pilot.app.query_one("#stats-display", StatsDisplay)
+        if stats.original_size > 0:
+            # Content has been rendered, give one more pause for layout
+            await pilot.pause()
+            return
+
+    # Get final state for error message
+    final_stats = pilot.app.query_one("#stats-display", StatsDisplay)
+    raise AssertionError(
+        "App did not render within expected time. "
+        f"StatsDisplay.original_size is still {final_stats.original_size}"
+    )
+
+
 def test_initial_state(snap_compare, initial_state_update):
     """Snapshot test for initial app state."""
     app = make_app_with_updates([initial_state_update])
-    assert snap_compare(app, terminal_size=(120, 40))
+    assert snap_compare(app, terminal_size=(120, 40), run_before=wait_for_render)
 
 
 def test_mid_reduction(snap_compare, mid_reduction_update):
     """Snapshot test for mid-reduction state."""
     app = make_app_with_updates([mid_reduction_update])
-    assert snap_compare(app, terminal_size=(120, 40))
+    assert snap_compare(app, terminal_size=(120, 40), run_before=wait_for_render)
 
 
 def test_hex_mode(snap_compare, hex_mode_update):
     """Snapshot test for hex mode display."""
     app = make_app_with_updates([hex_mode_update])
-    assert snap_compare(app, terminal_size=(120, 40))
+    assert snap_compare(app, terminal_size=(120, 40), run_before=wait_for_render)
 
 
 def test_large_file(snap_compare, large_file_update):
     """Snapshot test for large file with potential diff."""
     app = make_app_with_updates([large_file_update])
-    assert snap_compare(app, terminal_size=(120, 40))
+    assert snap_compare(app, terminal_size=(120, 40), run_before=wait_for_render)
 
 
 def test_small_terminal(snap_compare, mid_reduction_update):
     """Snapshot test with smaller terminal size."""
     app = make_app_with_updates([mid_reduction_update])
-    assert snap_compare(app, terminal_size=(80, 24))
+    assert snap_compare(app, terminal_size=(80, 24), run_before=wait_for_render)
 
 
 def test_wide_terminal(snap_compare, mid_reduction_update):
     """Snapshot test with wider terminal."""
     app = make_app_with_updates([mid_reduction_update])
-    assert snap_compare(app, terminal_size=(160, 50))
+    assert snap_compare(app, terminal_size=(160, 50), run_before=wait_for_render)
 
 
 @pytest.fixture