shrinkray 25.12.26.2__tar.gz → 25.12.27.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.26.2
+Version: 25.12.27.0
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

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

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "25.12.26.2"
+version = "25.12.27.0"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}
@@ -77,10 +77,8 @@ ignore = [
     "B007",  # unused loop variable
     "B023",  # function definition in loop
     "B904",  # raise without from - intentional in some exception handling
-    "C408",  # unnecessary dict() call - sometimes more readable
     "UP031", # use format specifiers - % format is fine
     "B018",  # useless expression - sometimes intentional for side effects
-    "C403",  # unnecessary list comprehension - sometimes more readable
     "UP022", # prefer capture_output - explicit is fine
 ]
 

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

@@ -271,20 +271,20 @@ def main(
     if not backup:
         backup = filename + os.extsep + "bak"
 
-    state_kwargs: dict[str, Any] = dict(
-        input_type=input_type,
-        in_place=in_place,
-        test=test,
-        timeout=timeout,
-        base=os.path.basename(filename),
-        parallelism=parallelism,
-        filename=filename,
-        formatter=formatter,
-        trivial_is_error=trivial_is_error,
-        seed=seed,
-        volume=volume,
-        clang_delta_executable=clang_delta_executable,
-    )
+    state_kwargs: dict[str, Any] = {
+        "input_type": input_type,
+        "in_place": in_place,
+        "test": test,
+        "timeout": timeout,
+        "base": os.path.basename(filename),
+        "parallelism": parallelism,
+        "filename": filename,
+        "formatter": formatter,
+        "trivial_is_error": trivial_is_error,
+        "seed": seed,
+        "volume": volume,
+        "clang_delta_executable": clang_delta_executable,
+    }
 
     state: ShrinkRayState[Any]
     ui: ShrinkRayUI[Any]

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/src/shrinkray/passes/sat.py

@@ -165,14 +165,14 @@ async def renumber_variables(problem: ReductionProblem[SAT]) -> None:
         result: SAT = []
         for clause in sat:
             new_clause: Clause = sorted(
-                set(
-                    [
+                {
+                    (
                         (renumbering[lit] if lit > 0 else -renumbering[-lit])
                         if abs(lit) in renumbering
                         else lit
-                        for lit in clause
-                    ]
-                )
+                    )
+                    for lit in clause
+                }
             )
             if len(set(map(abs, new_clause))) == len(new_clause):
                 result.append(new_clause)
@@ -290,7 +290,7 @@ class BooleanEquivalence(UnionFind[int]):
 
     def find(self, value: int) -> int:
         if not value:
-            raise ValueError("Invalid variable %r" % (value,))
+            raise ValueError(f"Invalid variable {value!r}")
         return super().find(value)
 
     def merge(self, left: int, right: int) -> None:

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/src/shrinkray/reducer.py

@@ -59,7 +59,9 @@ class Reducer[T](ABC):
     # Optional pass statistics tracking (implemented by ShrinkRay)
     pass_stats: "PassStatsTracker | None" = attrs.field(default=None, init=False)
     # Optional current pass tracking (implemented by ShrinkRay)
-    current_reduction_pass: "ReductionPass[T] | None" = attrs.field(default=None, init=False)
+    current_reduction_pass: "ReductionPass[T] | None" = attrs.field(
+        default=None, init=False
+    )
 
     @contextmanager
     def backtrack(self, restart: T) -> Generator[None, None, None]:
@@ -192,7 +194,9 @@ class ShrinkRay(Reducer[bytes]):
     # Pass control: disabled passes and skip functionality
     disabled_passes: set[str] = attrs.Factory(set)
     _skip_requested: bool = attrs.field(default=False, init=False)
-    _current_pass_scope: "trio.CancelScope | None" = attrs.field(default=None, init=False)
+    _current_pass_scope: "trio.CancelScope | None" = attrs.field(
+        default=None, init=False
+    )
     _passes_were_skipped: bool = attrs.field(default=False, init=False)
 
     def disable_pass(self, pass_name: str) -> None:

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

@@ -105,12 +105,12 @@ class ShrinkRayState[TestCase](ABC):
         else:
             command = self.test
 
-        kwargs: dict[str, Any] = dict(
-            universal_newlines=False,
-            preexec_fn=os.setsid,
-            cwd=cwd,
-            check=False,
-        )
+        kwargs: dict[str, Any] = {
+            "universal_newlines": False,
+            "preexec_fn": os.setsid,
+            "cwd": cwd,
+            "check": False,
+        }
         if self.input_type.enabled(self._InputType.stdin) and not os.path.isdir(
             working
         ):
@@ -562,10 +562,10 @@ class ShrinkRayDirectoryState(ShrinkRayState[dict[str, bytes]]):
                 sorted((k, shortlex(v)) for k, v in test_case.items()),
             )
 
-        return dict(
-            sort_key=dict_sort_key,
-            size=dict_size,
-        )
+        return {
+            "sort_key": dict_sort_key,
+            "size": dict_size,
+        }
 
     def new_reducer(
         self, problem: ReductionProblem[dict[str, bytes]]

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

@@ -4,7 +4,7 @@ import asyncio
 import sys
 import traceback
 import uuid
-from collections.abc import AsyncIterator
+from collections.abc import AsyncGenerator
 from typing import Any
 
 from shrinkray.subprocess.protocol import (
@@ -200,7 +200,7 @@ class SubprocessClient:
             traceback.print_exc()
             return Response(id="", error="Failed to skip pass")
 
-    async def get_progress_updates(self) -> AsyncIterator[ProgressUpdate]:
+    async def get_progress_updates(self) -> AsyncGenerator[ProgressUpdate, None]:
         """Yield progress updates as they arrive."""
         while not self._completed:
             try:

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

@@ -4,6 +4,7 @@ import os
 import sys
 import time
 import traceback
+from contextlib import aclosing
 from typing import Any, Protocol
 
 import trio
@@ -25,6 +26,7 @@ class InputStream(Protocol):
 
     def __aiter__(self) -> "InputStream": ...
     async def __anext__(self) -> bytes | bytearray: ...
+    async def aclose(self) -> None: ...
 
 
 class OutputStream(Protocol):
@@ -88,12 +90,13 @@ class ReducerWorker:
             stream = trio.lowlevel.FdStream(os.dup(sys.stdin.fileno()))
 
         buffer = b""
-        async for chunk in stream:
-            buffer += chunk
-            while b"\n" in buffer:
-                line, buffer = buffer.split(b"\n", 1)
-                if line:
-                    await self.handle_line(line.decode("utf-8"))
+        async with aclosing(stream) as aiter:
+            async for chunk in aiter:
+                buffer += chunk
+                while b"\n" in buffer:
+                    line, buffer = buffer.split(b"\n", 1)
+                    if line:
+                        await self.handle_line(line.decode("utf-8"))
 
     async def handle_line(self, line: str) -> None:
         """Handle a single command line."""
@@ -124,7 +127,9 @@ class ReducerWorker:
             case "skip_pass":
                 return self._handle_skip_pass(request.id)
             case _:
-                return Response(id=request.id, error=f"Unknown command: {request.command}")
+                return Response(
+                    id=request.id, error=f"Unknown command: {request.command}"
+                )
 
     async def _handle_start(self, request_id: str, params: dict) -> Response:
         """Start the reduction process."""
@@ -181,20 +186,20 @@ class ReducerWorker:
             if clang_delta_path:
                 clang_delta_executable = ClangDelta(clang_delta_path)
 
-        state_kwargs: dict[str, Any] = dict(
-            input_type=input_type,
-            in_place=in_place,
-            test=test,
-            timeout=timeout,
-            base=os.path.basename(filename),
-            parallelism=parallelism,
-            filename=filename,
-            formatter=formatter,
-            trivial_is_error=trivial_is_error,
-            seed=seed,
-            volume=volume,
-            clang_delta_executable=clang_delta_executable,
-        )
+        state_kwargs: dict[str, Any] = {
+            "input_type": input_type,
+            "in_place": in_place,
+            "test": test,
+            "timeout": timeout,
+            "base": os.path.basename(filename),
+            "parallelism": parallelism,
+            "filename": filename,
+            "formatter": formatter,
+            "trivial_is_error": trivial_is_error,
+            "seed": seed,
+            "volume": volume,
+            "clang_delta_executable": clang_delta_executable,
+        }
 
         if os.path.isdir(filename):
             files = [os.path.join(d, f) for d, _, fs in os.walk(filename) for f in fs]
@@ -263,7 +268,9 @@ class ReducerWorker:
 
         if self.reducer is not None and hasattr(self.reducer, "disable_pass"):
             self.reducer.disable_pass(pass_name)
-            return Response(id=request_id, result={"status": "disabled", "pass_name": pass_name})
+            return Response(
+                id=request_id, result={"status": "disabled", "pass_name": pass_name}
+            )
         return Response(id=request_id, error="Reducer does not support pass control")
 
     def _handle_enable_pass(self, request_id: str, params: dict) -> Response:
@@ -281,7 +288,9 @@ class ReducerWorker:
 
         if self.reducer is not None and hasattr(self.reducer, "enable_pass"):
             self.reducer.enable_pass(pass_name)
-            return Response(id=request_id, result={"status": "enabled", "pass_name": pass_name})
+            return Response(
+                id=request_id, result={"status": "enabled", "pass_name": pass_name}
+            )
         return Response(id=request_id, error="Reducer does not support pass control")
 
     def _handle_skip_pass(self, request_id: str) -> Response:

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

@@ -1,7 +1,9 @@
 """Textual-based TUI for Shrink Ray."""
 
 import os
-from collections.abc import AsyncIterator
+import traceback
+from collections.abc import AsyncGenerator
+from contextlib import aclosing
 from datetime import timedelta
 from typing import Literal, Protocol
 
@@ -114,7 +116,7 @@ class ReductionClientProtocol(Protocol):
 
     @property
     def error_message(self) -> str | None: ...
-    def get_progress_updates(self) -> AsyncIterator[ProgressUpdate]: ...
+    def get_progress_updates(self) -> AsyncGenerator[ProgressUpdate, None]: ...
     @property
     def is_completed(self) -> bool: ...
 
@@ -485,7 +487,9 @@ class PassStatsScreen(ModalScreen[None]):
                     reductions = str(ps.successful_reductions)
                     success = f"{ps.success_rate:.1f}%"
 
-                table.add_row(checkbox, name, runs, bytes_del, tests, reductions, success)
+                table.add_row(
+                    checkbox, name, runs, bytes_del, tests, reductions, success
+                )
 
         # Restore cursor and scroll position after rebuilding
         # Only restore if the saved position is still valid
@@ -510,7 +514,9 @@ class PassStatsScreen(ModalScreen[None]):
             # Update footer with disabled count
             disabled_count = len(self.disabled_passes)
             if disabled_count > 0:
-                footer_text = f"Showing {len(self.pass_stats)} passes ({disabled_count} disabled)"
+                footer_text = (
+                    f"Showing {len(self.pass_stats)} passes ({disabled_count} disabled)"
+                )
             else:
                 footer_text = f"Showing {len(self.pass_stats)} passes in run order"
             footer = self.query_one("#stats-footer", Static)
@@ -713,18 +719,21 @@ class ShrinkRayApp(App[None]):
             stats_display = self.query_one("#stats-display", StatsDisplay)
             content_preview = self.query_one("#content-preview", ContentPreview)
 
-            async for update in self._client.get_progress_updates():
-                stats_display.update_stats(update)
-                content_preview.update_content(update.content_preview, update.hex_mode)
-                self._latest_pass_stats = update.pass_stats
-                self._current_pass_name = update.current_pass_name
-                self._disabled_passes = update.disabled_passes
+            async with aclosing(self._client.get_progress_updates()) as updates:
+                async for update in updates:
+                    stats_display.update_stats(update)
+                    content_preview.update_content(
+                        update.content_preview, update.hex_mode
+                    )
+                    self._latest_pass_stats = update.pass_stats
+                    self._current_pass_name = update.current_pass_name
+                    self._disabled_passes = update.disabled_passes
 
-                # Check if all passes are disabled
-                self._check_all_passes_disabled()
+                    # Check if all passes are disabled
+                    self._check_all_passes_disabled()
 
-                if self._client.is_completed:
-                    break
+                    if self._client.is_completed:
+                        break
 
             self._completed = True
 
@@ -739,6 +748,7 @@ class ShrinkRayApp(App[None]):
                 self.update_status("Reduction completed! Press 'q' to exit.")
 
         except Exception as e:
+            traceback.print_exc()
             self.exit(return_code=1, message=f"Error: {e}")
         finally:
             if self._owns_client and self._client:
@@ -750,7 +760,7 @@ class ShrinkRayApp(App[None]):
             all_pass_names = {ps.pass_name for ps in self._latest_pass_stats}
             if all_pass_names and all_pass_names <= set(self._disabled_passes):
                 self.update_status(
-                    "Reduction paused (all passes disabled) - " "[p] to re-enable passes"
+                    "Reduction paused (all passes disabled) - [p] to re-enable passes"
                 )
 
     def update_status(self, message: str) -> None:

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/src/shrinkray/work.py

@@ -13,7 +13,7 @@ Key concepts:
 
 import heapq
 from collections.abc import Awaitable, Callable, Sequence
-from contextlib import asynccontextmanager
+from contextlib import aclosing, asynccontextmanager
 from enum import IntEnum
 from itertools import islice
 from random import Random
@@ -100,8 +100,9 @@ class WorkContext:
                         async with parallel_map(
                             values, f, parallelism=min(self.parallelism, n)
                         ) as result:
-                            async for v in result:
-                                await send.send(v)
+                            async with aclosing(result) as aiter:
+                                async for v in aiter:
+                                    await send.send(v)
 
                         n *= 2
                 else:
@@ -122,9 +123,10 @@ class WorkContext:
             @nursery.start_soon
             async def _():
                 async with self.map(ls, apply) as results:
-                    async for x, v in results:
-                        if v:
-                            await send.send(x)
+                    async with aclosing(results) as aiter:
+                        async for x, v in aiter:
+                            if v:
+                                await send.send(x)
                     send.close()
 
             yield receive
@@ -139,8 +141,9 @@ class WorkContext:
         Will run in parallel if parallelism is enabled.
         """
         async with self.filter(ls, f) as filtered:
-            async for x in filtered:
-                return x
+            async with aclosing(filtered) as aiter:
+                async for x in aiter:
+                    return x
         raise NotFound()
 
     async def find_large_integer(self, f: Callable[[int], Awaitable[bool]]) -> int:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.26.2
+Version: 25.12.27.0
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/tests/test_clang_delta.py

@@ -166,9 +166,8 @@ async def test_apply_transformation_raises_clang_delta_error():
     error.stdout = b"Some error"
     error.stderr = b""
 
-    with patch("trio.run_process", side_effect=error):
-        with pytest.raises(ClangDeltaError):
-            await cd.apply_transformation("rename-var", 1, source)
+    with patch("trio.run_process", side_effect=error), pytest.raises(ClangDeltaError):
+        await cd.apply_transformation("rename-var", 1, source)
 
 
 async def test_pump_handles_assertion_failure():
@@ -238,14 +237,16 @@ def test_clang_delta_works_when_not_found():
 def test_clang_delta_works_when_execution_fails():
     """Test clang_delta_works returns False when clang_delta exists but fails to run."""
     clang_delta_works.cache_clear()
-    with patch(
-        "shrinkray.passes.clangdelta.find_clang_delta", return_value="/usr/bin/fake"
-    ):
-        with patch(
+    with (
+        patch(
+            "shrinkray.passes.clangdelta.find_clang_delta", return_value="/usr/bin/fake"
+        ),
+        patch(
             "shrinkray.passes.clangdelta.subprocess.run",
             side_effect=OSError("Library not found"),
-        ):
-            assert clang_delta_works() is False
+        ),
+    ):
+        assert clang_delta_works() is False
 
 
 def test_clang_delta_works_when_returns_nonzero():
@@ -254,13 +255,13 @@ def test_clang_delta_works_when_returns_nonzero():
     mock_result = MagicMock()
     mock_result.returncode = 1
 
-    with patch(
-        "shrinkray.passes.clangdelta.find_clang_delta", return_value="/usr/bin/fake"
+    with (
+        patch(
+            "shrinkray.passes.clangdelta.find_clang_delta", return_value="/usr/bin/fake"
+        ),
+        patch("shrinkray.passes.clangdelta.subprocess.run", return_value=mock_result),
     ):
-        with patch(
-            "shrinkray.passes.clangdelta.subprocess.run", return_value=mock_result
-        ):
-            assert clang_delta_works() is False
+        assert clang_delta_works() is False
 
 
 def test_find_clang_delta_when_found_in_path():
@@ -306,9 +307,8 @@ async def test_query_instances_raises_clang_delta_error():
     error.stdout = b"Some other error"
     error.stderr = b"More error info"
 
-    with patch("trio.run_process", side_effect=error):
-        with pytest.raises(ClangDeltaError):
-            await cd.query_instances("rename-var", b"int main() {}")
+    with patch("trio.run_process", side_effect=error), pytest.raises(ClangDeltaError):
+        await cd.query_instances("rename-var", b"int main() {}")
 
 
 async def test_query_instances_handles_assertion_failure():

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/tests/test_cli.py

@@ -103,28 +103,36 @@ def test_validate_ui_returns_value_when_provided():
 
 
 def test_validate_ui_returns_textual_for_tty():
-    with patch.object(sys.stdin, "isatty", return_value=True):
-        with patch.object(sys.stdout, "isatty", return_value=True):
-            result = validate_ui(None, None, None)
-            assert result == UIType.textual
+    with (
+        patch.object(sys.stdin, "isatty", return_value=True),
+        patch.object(sys.stdout, "isatty", return_value=True),
+    ):
+        result = validate_ui(None, None, None)
+        assert result == UIType.textual
 
 
 def test_validate_ui_returns_basic_for_non_tty_stdin():
-    with patch.object(sys.stdin, "isatty", return_value=False):
-        with patch.object(sys.stdout, "isatty", return_value=True):
-            result = validate_ui(None, None, None)
-            assert result == UIType.basic
+    with (
+        patch.object(sys.stdin, "isatty", return_value=False),
+        patch.object(sys.stdout, "isatty", return_value=True),
+    ):
+        result = validate_ui(None, None, None)
+        assert result == UIType.basic
 
 
 def test_validate_ui_returns_basic_for_non_tty_stdout():
-    with patch.object(sys.stdin, "isatty", return_value=True):
-        with patch.object(sys.stdout, "isatty", return_value=False):
-            result = validate_ui(None, None, None)
-            assert result == UIType.basic
+    with (
+        patch.object(sys.stdin, "isatty", return_value=True),
+        patch.object(sys.stdout, "isatty", return_value=False),
+    ):
+        result = validate_ui(None, None, None)
+        assert result == UIType.basic
 
 
 def test_validate_ui_returns_basic_for_non_tty_both():
-    with patch.object(sys.stdin, "isatty", return_value=False):
-        with patch.object(sys.stdout, "isatty", return_value=False):
-            result = validate_ui(None, None, None)
-            assert result == UIType.basic
+    with (
+        patch.object(sys.stdin, "isatty", return_value=False),
+        patch.object(sys.stdout, "isatty", return_value=False),
+    ):
+        result = validate_ui(None, None, None)
+        assert result == UIType.basic

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/tests/test_definitions.py

@@ -41,6 +41,7 @@ def test_format_is_valid_for_unparseable():
 
 async def test_compose_returns_early_on_parse_error():
     """Test that compose returns early when parsing fails after problem changes."""
+
     # Create a format that parses strings starting with "VALID:" successfully
     class SelectiveFormat(Format[str, str]):
         def parse(self, input: str) -> str:

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/tests/test_dimacs_cnf.py

@@ -213,10 +213,14 @@ def test_negating_map_repr():
     nm[3] = 4
     r = repr(nm)
     # Should contain both positive and negative mappings
-    assert "1" in r and "-1" in r
-    assert "2" in r and "-2" in r
-    assert "3" in r and "-3" in r
-    assert "4" in r and "-4" in r
+    assert "1" in r
+    assert "-1" in r
+    assert "2" in r
+    assert "-2" in r
+    assert "3" in r
+    assert "-3" in r
+    assert "4" in r
+    assert "-4" in r
 
 
 def test_unit_propagator_duplicate_unit():

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/tests/test_formatting.py

@@ -44,10 +44,12 @@ def test_find_python_command_checks_python_bin_directory():
 
 
 def test_find_python_command_returns_none_when_not_in_bin_dir():
-    with patch("shrinkray.formatting.which", return_value=None):
-        with patch("os.path.exists", return_value=False):
-            result = find_python_command("nonexistent")
-            assert result is None
+    with (
+        patch("shrinkray.formatting.which", return_value=None),
+        patch("os.path.exists", return_value=False),
+    ):
+        result = find_python_command("nonexistent")
+        assert result is None
 
 
 # === try_decode tests ===

{shrinkray-25.12.26.2 → shrinkray-25.12.27.0}/tests/test_generic_language.py

@@ -266,7 +266,6 @@ def test_normalize_identifiers_identifier_disappears():
 def test_regex_pass_with_compiled_pattern():
     """Test regex_pass with an already compiled pattern."""
 
-
     # Create a pass with a pre-compiled pattern
     pattern = re.compile(rb"[0-9]+")
 
@@ -345,7 +344,6 @@ async def test_normalize_identifiers_target_disappears():
     This can happen in concurrent scenarios or with modified problem classes.
     """
 
-
     # Create a mock problem that changes its current_test_case
     mock_problem = MagicMock()
     mock_problem.work = WorkContext(parallelism=1)