shrinkray 25.12.27.2__tar.gz → 25.12.28.0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "25.12.27.2"
+version = "25.12.28.0"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/__main__.py

@@ -17,18 +17,19 @@ from shrinkray.cli import (
     validate_command,
     validate_ui,
 )
+from shrinkray.formatting import determine_formatter_command
 from shrinkray.passes.clangdelta import (
     C_FILE_EXTENSIONS,
     ClangDelta,
     find_clang_delta,
 )
-from shrinkray.problem import InvalidInitialExample
 from shrinkray.state import (
     ShrinkRayDirectoryState,
     ShrinkRayState,
     ShrinkRayStateSingleFile,
 )
 from shrinkray.ui import BasicUI, ShrinkRayUI
+from shrinkray.validation import run_validation
 from shrinkray.work import Volume
 
 
@@ -39,12 +40,9 @@ async def run_shrink_ray(
     """Run the shrink ray reduction process."""
     async with trio.open_nursery() as nursery:
         problem = state.problem
-        try:
-            await problem.setup()
-        except* InvalidInitialExample as excs:
-            assert len(excs.exceptions) == 1
-            (e,) = excs.exceptions
-            await state.report_error(e)
+        # Validation runs before run_shrink_ray is called, so setup() should
+        # always succeed. If it doesn't, there's a bug and we want it to propagate.
+        await problem.setup()
 
         reducer = state.reducer
 
@@ -273,6 +271,26 @@ def main(
     if not backup:
         backup = filename + os.extsep + "bak"
 
+    # Run initial validation before any state setup
+    # This validates the interestingness test and formatter with proper output streaming
+    formatter_command = None
+    if not os.path.isdir(filename) and formatter.lower() != "none":
+        formatter_command = determine_formatter_command(formatter, filename)
+
+    validation_result = run_validation(
+        file_path=filename,
+        test=test,
+        input_type=input_type,
+        in_place=in_place,
+        formatter_command=formatter_command,
+    )
+
+    if not validation_result.success:
+        print(f"\nError: {validation_result.error_message}", file=sys.stderr)
+        sys.exit(1)
+
+    print("\nStarting reduction...", file=sys.stderr, flush=True)
+
     state_kwargs: dict[str, Any] = {
         "input_type": input_type,
         "in_place": in_place,
@@ -307,8 +325,6 @@ def main(
 
         state = ShrinkRayDirectoryState(initial=initial, **state_kwargs)
 
-        trio.run(state.check_formatter)
-
     else:
         try:
             os.remove(backup)
@@ -323,8 +339,6 @@ def main(
 
         state = ShrinkRayStateSingleFile(initial=initial, **state_kwargs)
 
-        trio.run(state.check_formatter)
-
     if ui_type == UIType.textual:
         from shrinkray.tui import run_textual_ui
 

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/passes/bytes.py

@@ -28,26 +28,6 @@ from shrinkray.passes.patching import Cuts, Patches, apply_patches
 from shrinkray.problem import Format, ReductionProblem
 
 
-@define(frozen=True)
-class Encoding(Format[bytes, str]):
-    """Format that decodes/encodes bytes using a character encoding."""
-
-    encoding: str
-
-    def __repr__(self) -> str:
-        return f"Encoding({repr(self.encoding)})"
-
-    @property
-    def name(self) -> str:
-        return self.encoding
-
-    def parse(self, input: bytes) -> str:
-        return input.decode(self.encoding)
-
-    def dumps(self, input: str) -> bytes:
-        return input.encode(self.encoding)
-
-
 @define(frozen=True)
 class Split(Format[bytes, list[bytes]]):
     """Format that splits bytes by a delimiter.
@@ -165,9 +145,6 @@ def tokenize(text: bytes) -> list[bytes]:
     return result
 
 
-MAX_DELETE_INTERVAL = 8
-
-
 async def lexeme_based_deletions(
     problem: ReductionProblem[bytes], min_size: int = 8
 ) -> None:
@@ -601,108 +578,6 @@ async def lower_individual_bytes(problem: ReductionProblem[bytes]) -> None:
     await apply_patches(problem, IndividualByteReplacement(), patches)
 
 
-RegionReplacementPatch = list[tuple[int, int, int]]
-
-
-class RegionReplacement(Patches[RegionReplacementPatch, bytes]):
-    @property
-    def empty(self) -> RegionReplacementPatch:
-        return []
-
-    def combine(self, *patches: RegionReplacementPatch) -> RegionReplacementPatch:
-        result: RegionReplacementPatch = []
-        for p in patches:
-            result.extend(p)
-        return result
-
-    def apply(self, patch: RegionReplacementPatch, target: bytes) -> bytes:
-        result = bytearray(target)
-        for i, j, d in patch:
-            if d < result[i]:
-                for k in range(i, j):
-                    result[k] = d
-        return bytes(result)
-
-    def size(self, patch: RegionReplacementPatch) -> int:
-        return 0
-
-
-async def short_replacements(problem: ReductionProblem[bytes]) -> None:
-    """Replace short regions with uniform byte values.
-
-    Tries replacing 1-4 byte regions with uniform values like 0, 1,
-    space, newline, or period. Useful for simplifying small sequences.
-    """
-    target = problem.current_test_case
-    patches = [
-        [(i, j, c)]
-        for c in [0, 1] + list(b"01 \t\n\r.")
-        for i in range(len(target))
-        if target[i] > c
-        for j in range(i + 1, min(i + 5, len(target) + 1))
-    ]
-
-    await apply_patches(problem, RegionReplacement(), patches)
-
-
-WHITESPACE = b" \t\r\n"
-
-
-async def sort_whitespace(problem: ReductionProblem[bytes]) -> None:
-    """NB: This is a stupid pass that we only really need for artificial
-    test cases, but it's helpful for allowing those artificial test cases
-    to expose other issues."""
-
-    whitespace_up_to = 0
-    while (
-        whitespace_up_to < len(problem.current_test_case)
-        and problem.current_test_case[whitespace_up_to] not in WHITESPACE
-    ):
-        whitespace_up_to += 1
-    while (
-        whitespace_up_to < len(problem.current_test_case)
-        and problem.current_test_case[whitespace_up_to] in WHITESPACE
-    ):
-        whitespace_up_to += 1
-
-    # If the initial whitespace ends with a newline we want to keep it doing
-    # that. This is mostly for Python purposes.
-    if (
-        whitespace_up_to > 0
-        and problem.current_test_case[whitespace_up_to - 1] == b"\n"[0]
-    ):
-        whitespace_up_to -= 1
-
-    i = whitespace_up_to + 1
-
-    while i < len(problem.current_test_case):
-        if problem.current_test_case[i] not in WHITESPACE:
-            i += 1
-            continue
-
-        async def can_move_to_whitespace(k: int) -> bool:
-            if i + k > len(problem.current_test_case):
-                return False
-
-            base = problem.current_test_case
-            target = base[i : i + k]
-
-            if any(c not in WHITESPACE for c in target):
-                return False
-
-            prefix = base[:whitespace_up_to]
-            attempt = prefix + target + base[whitespace_up_to:i] + base[i + k :]
-            return await problem.is_interesting(attempt)
-
-        k = await problem.work.find_large_integer(can_move_to_whitespace)
-        whitespace_up_to += k
-        i += k + 1
-    test_case = problem.current_test_case
-    await problem.is_interesting(
-        bytes(sorted(test_case[:whitespace_up_to])) + test_case[whitespace_up_to:]
-    )
-
-
 # These are some cheat substitutions that are sometimes helpful, but mostly
 # for passing stupid tests.
 STANDARD_SUBSTITUTIONS = [(b"\0\0", b"\1"), (b"\0\0", b"\xff")]

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/passes/clangdelta.py

@@ -1,6 +1,5 @@
 import os
 import subprocess
-from functools import lru_cache
 from glob import glob
 from shutil import which
 from tempfile import NamedTemporaryFile
@@ -26,29 +25,6 @@ def find_clang_delta():
     return clang_delta
 
 
-@lru_cache(maxsize=1)
-def clang_delta_works() -> bool:
-    """Check if clang_delta can actually execute.
-
-    This verifies not just that the binary exists, but that it can run.
-    On some systems (e.g., Ubuntu 24.04), creduce is installed but
-    clang_delta fails at runtime due to shared library issues.
-    """
-    clang_delta = find_clang_delta()
-    if not clang_delta:
-        return False
-    try:
-        # Run a simple test to verify clang_delta works
-        result = subprocess.run(
-            [clang_delta, "--help"],
-            capture_output=True,
-            timeout=5,
-        )
-        return result.returncode == 0
-    except (OSError, subprocess.TimeoutExpired):
-        return False
-
-
 TRANSFORMATIONS: list[str] = [
     "aggregate-to-scalar",
     "binop-simplification",

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/passes/genericlanguages.py

@@ -9,7 +9,6 @@ from string import ascii_lowercase, ascii_uppercase
 from typing import AnyStr
 
 import trio
-from attr import define
 
 from shrinkray.passes.bytes import ByteReplacement, delete_intervals
 from shrinkray.passes.definitions import ReductionPass
@@ -24,25 +23,6 @@ from shrinkray.problem import (
 from shrinkray.work import NotFound
 
 
-@define(frozen=True)
-class Substring(Format[AnyStr, AnyStr]):
-    prefix: AnyStr
-    suffix: AnyStr
-
-    @property
-    def name(self) -> str:
-        return f"Substring({len(self.prefix)}, {len(self.suffix)})"
-
-    def parse(self, input: AnyStr) -> AnyStr:
-        if input.startswith(self.prefix) and input.endswith(self.suffix):
-            return input[len(self.prefix) : len(input) - len(self.suffix)]
-        else:
-            raise ParseError()
-
-    def dumps(self, input: AnyStr) -> AnyStr:
-        return self.prefix + input + self.suffix
-
-
 class RegionReplacingPatches(Patches[dict[int, AnyStr], AnyStr]):
     def __init__(self, regions: list[tuple[int, int]]):
         assert regions

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/passes/json.py

@@ -9,14 +9,6 @@ from shrinkray.passes.patching import Patches, apply_patches
 from shrinkray.problem import Format, ParseError, ReductionProblem
 
 
-def is_json(s: bytes) -> bool:
-    try:
-        json.loads(s)
-        return True
-    except ValueError:
-        return False
-
-
 @define(frozen=True)
 class _JSON(Format[bytes, Any]):
     def __repr__(self) -> str:

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/passes/patching.py

@@ -1,7 +1,5 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable, Sequence
-from enum import Enum
-from random import Random
 from typing import Any, TypeVar, cast
 
 import trio
@@ -52,27 +50,6 @@ class SetPatches[T, TargetType](Patches[frozenset[T], TargetType]):
         return len(patch)
 
 
-class ListPatches[T, TargetType](Patches[list[T], TargetType]):
-    def __init__(self, apply: Callable[[list[T], TargetType], TargetType]):
-        self.__apply = apply
-
-    @property
-    def empty(self):
-        return []
-
-    def combine(self, *patches: list[T]) -> list[T]:
-        result = []
-        for p in patches:
-            result.extend(p)
-        return result
-
-    def apply(self, patch: list[T], target: TargetType) -> TargetType:
-        return self.__apply(patch, target)
-
-    def size(self, patch: list[T]) -> int:
-        return len(patch)
-
-
 class PatchApplier[PatchType, TargetType]:
     def __init__(
         self,
@@ -174,15 +151,6 @@ class PatchApplier[PatchType, TargetType]:
             return await receive_merge_result.receive()
 
 
-class Direction(Enum):
-    LEFT = 0
-    RIGHT = 1
-
-
-class Completed(Exception):
-    pass
-
-
 async def apply_patches[PatchType, TargetType](
     problem: ReductionProblem[TargetType],
     patch_info: Patches[PatchType, TargetType],
@@ -220,37 +188,6 @@ async def apply_patches[PatchType, TargetType](
                     await applier.try_apply_patch(patch)
 
 
-class LazyMutableRange:
-    def __init__(self, n: int):
-        self.__size = n
-        self.__mask: dict[int, int] = {}
-
-    def __getitem__(self, i: int) -> int:
-        return self.__mask.get(i, i)
-
-    def __setitem__(self, i: int, v: int) -> None:
-        self.__mask[i] = v
-
-    def __len__(self) -> int:
-        return self.__size
-
-    def pop(self) -> int:
-        i = len(self) - 1
-        result = self[i]
-        self.__size = i
-        self.__mask.pop(i, None)
-        return result
-
-
-def lazy_shuffle[T](seq: Sequence[T], rnd: Random) -> Iterable[T]:
-    indices = LazyMutableRange(len(seq))
-    while indices:
-        j = len(indices) - 1
-        i = rnd.randrange(0, len(indices))
-        indices[i], indices[j] = indices[j], indices[i]
-        yield seq[indices.pop()]
-
-
 CutPatch = list[tuple[int, int]]
 
 

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/passes/sequences.py

@@ -18,31 +18,6 @@ async def delete_elements[Seq: Sequence[Any]](problem: ReductionProblem[Seq]) ->
     )
 
 
-def merged_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
-    normalized: list[list[int]] = []
-    for start, end in sorted(map(tuple, intervals)):
-        if normalized and normalized[-1][-1] >= start:
-            normalized[-1][-1] = max(normalized[-1][-1], end)
-        else:
-            normalized.append([start, end])
-    return list(map(tuple, normalized))  # type: ignore
-
-
-def with_deletions[Seq: Sequence[Any]](
-    target: Seq, deletions: list[tuple[int, int]]
-) -> Seq:
-    result: list[Any] = []
-    prev = 0
-    total_deleted = 0
-    for start, end in deletions:
-        total_deleted += end - start
-        result.extend(target[prev:start])
-        prev = end
-    result.extend(target[prev:])
-    assert len(result) + total_deleted == len(target)
-    return type(target)(result)  # type: ignore
-
-
 def block_deletion[Seq: Sequence[Any]](
     min_block: int, max_block: int
 ) -> ReductionPass[Seq]:

{shrinkray-25.12.27.2 → shrinkray-25.12.28.0}/src/shrinkray/reducer.py

@@ -99,50 +99,6 @@ class Reducer[T](ABC):
         """Skip the currently running pass. Override in subclasses for pass control."""
 
 
-@define
-class BasicReducer[T](Reducer[T]):
-    reduction_passes: Iterable[ReductionPass[T]]
-    pumps: Iterable[ReductionPump[T]] = ()
-    _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)
-
-    async def run(self) -> None:
-        await self.target.setup()
-
-        while True:
-            prev = self.target.current_test_case
-            for rp in self.reduction_passes:
-                self.status = f"Running reduction pass {rp.__name__}"
-                await self.run_pass(rp)
-            for pump in self.pumps:
-                self.status = f"Pumping with {pump.__name__}"
-                pumped = await pump(self.target)
-                if pumped != self.target.current_test_case:
-                    with self.backtrack(pumped):
-                        for rp in self.reduction_passes:
-                            self.status = f"Running reduction pass {rp.__name__} under pump {pump.__name__}"
-                            await self.run_pass(rp)
-            if prev == self.target.current_test_case:
-                return
-
-
-class RestartPass(Exception):
-    pass
-
-
 @define
 class PassStats:
     """Statistics for a single reduction pass."""
@@ -181,12 +137,6 @@ class PassStatsTracker:
         return list(self._stats.values())
 
 
-class SkipPass(Exception):
-    """Raised to skip the current pass."""
-
-    pass
-
-
 @define
 class ShrinkRay(Reducer[bytes]):
     clang_delta: ClangDelta | None = None