shrinkray 0.0.0__py3-none-any.whl → 25.12.26.0__py3-none-any.whl

shrinkray/reducer.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
-from collections.abc import Generator
+from collections.abc import Generator, Iterable
 from contextlib import contextmanager
-from typing import Any, Generic, Iterable, Optional, TypeVar
+from typing import Any
 
 import attrs
 import trio
@@ -15,6 +15,7 @@ from shrinkray.passes.bytes import (
     hollow,
     lexeme_based_deletions,
     lift_braces,
+    line_sorter,
     lower_bytes,
     lower_individual_bytes,
     remove_indents,
@@ -23,8 +24,17 @@ from shrinkray.passes.bytes import (
     short_deletions,
     standard_substitutions,
 )
-from shrinkray.passes.clangdelta import C_FILE_EXTENSIONS, ClangDelta, clang_delta_pumps
-from shrinkray.passes.definitions import Format, ReductionPass, ReductionPump, compose
+from shrinkray.passes.clangdelta import (
+    C_FILE_EXTENSIONS,
+    ClangDelta,
+    clang_delta_pumps,
+)
+from shrinkray.passes.definitions import (
+    Format,
+    ReductionPass,
+    ReductionPump,
+    compose,
+)
 from shrinkray.passes.genericlanguages import (
     combine_expressions,
     cut_comment_like_things,
@@ -39,16 +49,18 @@ from shrinkray.passes.patching import PatchApplier, Patches
 from shrinkray.passes.python import PYTHON_PASSES, is_python
 from shrinkray.passes.sat import SAT_PASSES, DimacsCNF
 from shrinkray.passes.sequences import block_deletion, delete_duplicates
-from shrinkray.problem import ReductionProblem, shortlex
-
-S = TypeVar("S")
-T = TypeVar("T")
+from shrinkray.problem import ReductionProblem, ReductionStats, shortlex
 
 
 @define
-class Reducer(Generic[T], ABC):
+class Reducer[T](ABC):
     target: ReductionProblem[T]
 
+    # 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)
+
     @contextmanager
     def backtrack(self, restart: T) -> Generator[None, None, None]:
         current = self.target
@@ -65,16 +77,38 @@ class Reducer(Generic[T], ABC):
     def status(self) -> str:
         return ""
 
+    @property
+    def disabled_passes(self) -> set[str]:
+        """Set of disabled pass names. Override in subclasses for pass control."""
+        return set()
+
+    def disable_pass(self, pass_name: str) -> None:  # noqa: B027
+        """Disable a pass by name. Override in subclasses for pass control."""
+
+    def enable_pass(self, pass_name: str) -> None:  # noqa: B027
+        """Enable a pass by name. Override in subclasses for pass control."""
+
+    def skip_current_pass(self) -> None:  # noqa: B027
+        """Skip the currently running pass. Override in subclasses for pass control."""
+
 
 @define
-class BasicReducer(Reducer[T]):
+class BasicReducer[T](Reducer[T]):
     reduction_passes: Iterable[ReductionPass[T]]
     pumps: Iterable[ReductionPump[T]] = ()
-    status: str = "Starting up"
+    _status: str = "Starting up"
 
     def __attrs_post_init__(self) -> None:
         self.reduction_passes = list(self.reduction_passes)
 
+    @property
+    def status(self) -> str:
+        return self._status
+
+    @status.setter
+    def status(self, value: str) -> None:
+        self._status = value
+
     async def run_pass(self, rp: ReductionPass[T]) -> None:
         await rp(self.target)
 
@@ -102,14 +136,88 @@ class RestartPass(Exception):
     pass
 
 
+@define
+class PassStats:
+    """Statistics for a single reduction pass."""
+
+    pass_name: str
+    bytes_deleted: int = 0
+    run_count: int = 0
+    test_evaluations: int = 0
+    successful_reductions: int = 0
+
+    @property
+    def success_rate(self) -> float:
+        """Percentage of test evaluations that led to a reduction."""
+        if self.test_evaluations == 0:
+            return 0.0
+        return (self.successful_reductions / self.test_evaluations) * 100.0
+
+
+@define
+class PassStatsTracker:
+    """Tracks statistics for all reduction passes.
+
+    Python 3.7+ dicts maintain insertion order, so stats are returned
+    in the order passes were first run.
+    """
+
+    _stats: dict[str, PassStats] = attrs.Factory(dict)
+
+    def get_or_create(self, pass_name: str) -> PassStats:
+        if pass_name not in self._stats:
+            self._stats[pass_name] = PassStats(pass_name=pass_name)
+        return self._stats[pass_name]
+
+    def get_stats_in_order(self) -> list[PassStats]:
+        """Get stats in the order passes were first run."""
+        return list(self._stats.values())
+
+
+class SkipPass(Exception):
+    """Raised to skip the current pass."""
+
+    pass
+
+
 @define
 class ShrinkRay(Reducer[bytes]):
-    clang_delta: Optional[ClangDelta] = None
+    clang_delta: ClangDelta | None = None
 
-    current_reduction_pass: Optional[ReductionPass[bytes]] = None
-    current_pump: Optional[ReductionPump[bytes]] = None
+    current_pump: ReductionPump[bytes] | None = None
 
     unlocked_ok_passes: bool = False
+    pass_stats: PassStatsTracker | None = attrs.Factory(PassStatsTracker)
+
+    # 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)
+    _passes_were_skipped: bool = attrs.field(default=False, init=False)
+
+    def disable_pass(self, pass_name: str) -> None:
+        """Disable a pass by name. If it's currently running, skip it."""
+        self.disabled_passes.add(pass_name)
+        # If this pass is currently running, skip it
+        if (
+            self.current_reduction_pass is not None
+            and self.current_reduction_pass.__name__ == pass_name
+        ):
+            self.skip_current_pass()
+
+    def enable_pass(self, pass_name: str) -> None:
+        """Enable a previously disabled pass."""
+        self.disabled_passes.discard(pass_name)
+
+    def is_pass_disabled(self, pass_name: str) -> bool:
+        """Check if a pass is disabled."""
+        return pass_name in self.disabled_passes
+
+    def skip_current_pass(self) -> None:
+        """Request to skip the currently running pass."""
+        self._skip_requested = True
+        if self._current_pass_scope is not None:
+            self._current_pass_scope.cancel()
 
     initial_cuts: list[ReductionPass[bytes]] = attrs.Factory(
         lambda: [
@@ -131,13 +239,13 @@ class ShrinkRay(Reducer[bytes]):
             remove_indents,
             hollow,
             lift_braces,
-            delete_byte_spans,
             debracket,
         ]
     )
 
     ok_passes: list[ReductionPass[bytes]] = attrs.Factory(
         lambda: [
+            delete_byte_spans,
             compose(Split(b"\n"), block_deletion(11, 20)),
             remove_indents,
             remove_whitespace,
@@ -149,6 +257,7 @@ class ShrinkRay(Reducer[bytes]):
             lexeme_based_deletions,
             short_deletions,
             normalize_identifiers,
+            line_sorter,
         ]
     )
 
@@ -169,21 +278,21 @@ class ShrinkRay(Reducer[bytes]):
 
     def __attrs_post_init__(self) -> None:
         if is_python(self.target.current_test_case):
-            self.great_passes[:0] = PYTHON_PASSES
-            self.initial_cuts[:0] = PYTHON_PASSES
+            self.great_passes.extend(PYTHON_PASSES)
+            self.initial_cuts.extend(PYTHON_PASSES)
         self.register_format_specific_pass(JSON, JSON_PASSES)
         self.register_format_specific_pass(
             DimacsCNF,
             SAT_PASSES,
         )
 
-    def register_format_specific_pass(
+    def register_format_specific_pass[T](
         self, format: Format[bytes, T], passes: Iterable[ReductionPass[T]]
     ):
         if format.is_valid(self.target.current_test_case):
             composed = [compose(format, p) for p in passes]
-            self.great_passes[:0] = composed
-            self.initial_cuts[:0] = composed
+            self.great_passes.extend(composed)
+            self.initial_cuts.extend(composed)
 
     @property
     def pumps(self) -> Iterable[ReductionPump[bytes]]:
@@ -206,12 +315,39 @@ class ShrinkRay(Reducer[bytes]):
                 return f"Running reduction pump {self.current_pump.__name__}"
 
     async def run_pass(self, rp: ReductionPass[bytes]) -> None:
+        pass_name = rp.__name__
+
+        # Skip if pass is disabled
+        if self.is_pass_disabled(pass_name):
+            return
+
         try:
             assert self.current_reduction_pass is None
             self.current_reduction_pass = rp
-            await rp(self.target)
+            self._skip_requested = False
+
+            # Get or create stats entry for this pass
+            assert self.pass_stats is not None  # Always set by Factory
+            stats_entry = self.pass_stats.get_or_create(pass_name)
+            stats_entry.run_count += 1
+
+            # Set current pass stats on the problem for real-time updates
+            self.target.current_pass_stats = stats_entry
+
+            # Run the pass with a cancel scope that can be externally cancelled
+            with trio.CancelScope() as scope:
+                self._current_pass_scope = scope
+                await rp(self.target)
+
+            # If the pass was cancelled/skipped, mark that passes were skipped
+            if scope.cancelled_caught:
+                self._passes_were_skipped = True
+
         finally:
             self.current_reduction_pass = None
+            self.target.current_pass_stats = None
+            self._current_pass_scope = None
+            self._skip_requested = False
 
     async def pump(self, rp: ReductionPump[bytes]) -> None:
         try:
@@ -237,8 +373,24 @@ class ShrinkRay(Reducer[bytes]):
             self.current_pump = None
 
     async def run_great_passes(self) -> None:
-        for rp in self.great_passes:
-            await self.run_pass(rp)
+        current = self.great_passes
+        while True:
+            prev = self.target.current_test_case
+            successful = []
+            for rp in current:
+                size = self.target.current_size
+                await self.run_pass(rp)
+                if self.target.current_size < size:
+                    successful.append(rp)
+            if self.target.current_test_case == prev:
+                if len(current) == len(self.great_passes):
+                    break
+                else:
+                    current = self.great_passes
+            elif not successful:
+                current = self.great_passes
+            else:
+                current = successful
 
     async def run_ok_passes(self) -> None:
         for rp in self.ok_passes:
@@ -325,6 +477,9 @@ class ShrinkRay(Reducer[bytes]):
         await self.initial_cut()
 
         while True:
+            # Reset skip tracking for this iteration
+            self._passes_were_skipped = False
+
             prev = self.target.current_test_case
             await self.run_some_passes()
             if self.target.current_test_case != prev:
@@ -332,7 +487,10 @@ class ShrinkRay(Reducer[bytes]):
             for pump in self.pumps:
                 await self.pump(pump)
             if self.target.current_test_case == prev:
-                break
+                # Only terminate if no passes were skipped
+                # If passes were skipped, we need another full run to be sure
+                if not self._passes_were_skipped:
+                    break
 
 
 class UpdateKeys(Patches[dict[str, bytes], dict[str, bytes]]):
@@ -374,6 +532,10 @@ class KeyProblem(ReductionProblem[bytes]):
     def current_test_case(self) -> bytes:
         return self.base_problem.current_test_case[self.key]
 
+    @property
+    def stats(self) -> ReductionStats:
+        return self.base_problem.stats
+
     async def is_interesting(self, test_case: bytes) -> bool:
         return await self.applier.try_apply_patch({self.key: test_case})
 
@@ -389,7 +551,7 @@ class KeyProblem(ReductionProblem[bytes]):
 
 @define
 class DirectoryShrinkRay(Reducer[dict[str, bytes]]):
-    clang_delta: Optional[ClangDelta] = None
+    clang_delta: ClangDelta | None = None
 
     async def run(self):
         prev = None