shrinkray 25.12.27.3__tar.gz → 25.12.28.0__tar.gz

{shrinkray-25.12.27.3/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.3
+Version: 25.12.28.0
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

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

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

{shrinkray-25.12.27.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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

{shrinkray-25.12.27.3 → shrinkray-25.12.28.0}/src/shrinkray/state.py

@@ -11,7 +11,7 @@ from abc import ABC, abstractmethod
 from collections import deque
 from datetime import timedelta
 from tempfile import TemporaryDirectory
-from typing import Any, TypeVar
+from typing import Any
 
 import humanize
 import trio
@@ -28,9 +28,6 @@ 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

{shrinkray-25.12.27.3 → shrinkray-25.12.28.0}/src/shrinkray/subprocess/__init__.py

@@ -5,9 +5,7 @@ from shrinkray.subprocess.protocol import (
     ProgressUpdate,
     Request,
     Response,
-    decode_bytes,
     deserialize,
-    encode_bytes,
     serialize,
 )
 
@@ -18,7 +16,5 @@ __all__ = [
     "ProgressUpdate",
     "serialize",
     "deserialize",
-    "encode_bytes",
-    "decode_bytes",
     "SubprocessClient",
 ]

{shrinkray-25.12.27.3 → shrinkray-25.12.28.0}/src/shrinkray/subprocess/protocol.py

@@ -1,6 +1,5 @@
 """Line-oriented JSON protocol for subprocess communication."""
 
-import base64
 import json
 from dataclasses import dataclass, field
 from typing import Any
@@ -186,13 +185,3 @@ def deserialize(line: str) -> Request | Response | ProgressUpdate:
         command=data["command"],
         params=data.get("params", {}),
     )
-
-
-def encode_bytes(data: bytes) -> str:
-    """Encode bytes to base64 string for JSON transport."""
-    return base64.b64encode(data).decode("ascii")
-
-
-def decode_bytes(data: str) -> bytes:
-    """Decode base64 string back to bytes."""
-    return base64.b64decode(data.encode("ascii"))

{shrinkray-25.12.27.3 → shrinkray-25.12.28.0}/src/shrinkray/subprocess/worker.py

@@ -37,14 +37,6 @@ class OutputStream(Protocol):
     async def send(self, data: bytes) -> None: ...
 
 
-class StdoutStream:
-    """Wrapper around sys.stdout for the OutputStream protocol."""
-
-    async def send(self, data: bytes) -> None:
-        sys.stdout.write(data.decode("utf-8"))
-        sys.stdout.flush()
-
-
 class ReducerWorker:
     """Runs the reducer in a subprocess with JSON protocol communication."""
 

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

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

{shrinkray-25.12.27.3 → shrinkray-25.12.28.0}/src/shrinkray.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ pyproject.toml
 src/shrinkray/__init__.py
 src/shrinkray/__main__.py
 src/shrinkray/cli.py
-src/shrinkray/display.py
 src/shrinkray/formatting.py
 src/shrinkray/problem.py
 src/shrinkray/process.py
@@ -40,7 +39,6 @@ tests/test_clang_delta.py
 tests/test_cli.py
 tests/test_definitions.py
 tests/test_dimacs_cnf.py
-tests/test_display.py
 tests/test_formatting.py
 tests/test_generic_language.py
 tests/test_generic_shrinking_properties.py

{shrinkray-25.12.27.3 → shrinkray-25.12.28.0}/tests/test_byte_reduction_passes.py

@@ -1,12 +1,10 @@
 import ast
-from collections import Counter
 
 import pytest
-from hypothesis import assume, example, given
+from hypothesis import example, given
 from hypothesis import strategies as st
 
 from shrinkray.passes.bytes import (
-    WHITESPACE,
     ByteReplacement,
     debracket,
     find_ngram_endpoints,
@@ -14,10 +12,8 @@ from shrinkray.passes.bytes import (
     lower_bytes,
     lower_individual_bytes,
     short_deletions,
-    sort_whitespace,
 )
 from shrinkray.passes.patching import apply_patches
-from shrinkray.passes.python import is_python
 from shrinkray.problem import BasicReductionProblem, shortlex
 from shrinkray.work import WorkContext
 from tests.helpers import assert_reduces_to, direct_reductions, reduce_with
@@ -52,98 +48,6 @@ def test_ngram_endpoints(b):
     find_ngram_endpoints(b)
 
 
-def count_whitespace(b):
-    return len([c for c in b if c in WHITESPACE])
-
-
-def count_regions(b):
-    n = 0
-    is_whitespace_last = True
-    for c in b:
-        typ = c in WHITESPACE
-        if not typ and is_whitespace_last:
-            n += 1
-        is_whitespace_last = typ
-    return n
-
-
-@pytest.mark.skip
-@example(initial=b"\n0\r")
-@given(st.builds(bytes, st.lists(st.sampled_from(b"\t\n\r 0123."))))
-def test_sorting_whitespace(initial):
-    initial_count = count_whitespace(initial)
-
-    assume(initial_count > 0)
-
-    def is_interesting(tc):
-        assert count_whitespace(tc) == initial_count
-        assert Counter(tc) == Counter(initial)
-        return True
-
-    result = reduce_with([sort_whitespace], initial, is_interesting)
-
-    for i, c in enumerate(result):
-        assert (c in WHITESPACE) == (i < initial_count)
-
-
-@pytest.mark.skip
-@given(st.builds(bytes, st.lists(st.sampled_from(b"\t\n\r 0123."))))
-def test_sorting_whitespace_preserving_regions(initial):
-    initial_count = count_whitespace(initial)
-    initial_regions = count_regions(initial)
-
-    assume(initial_count > 0)
-    assume(initial_regions > 1)
-
-    def is_interesting(tc):
-        assert count_whitespace(tc) == initial_count
-        assert Counter(tc) == Counter(initial)
-        return count_regions(tc) == initial_regions
-
-    result = reduce_with([sort_whitespace], initial, is_interesting)
-
-    for run in runs_of_whitespace(result)[1:]:
-        assert len(run) <= 1
-
-
-@pytest.mark.skip
-@pytest.mark.parametrize(
-    "initial",
-    [
-        b"\t\t\t\t\nfrom\t\t\t\t\t\t\t\t\t\t.\timport\tA\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\nfrom\t\t\t.\t\t\t\t\t\t\t\t\t\timport\t\to\t\t\t\t\t\t\t\t\nfrom\t\t.\t\t\t\t\t\t\t\timport\t\tr\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t",
-        b"from\t\t.\t\t\t\t\t\t\t\t\timport\ta\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\nclass\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\ta\t\t\t\t\t\t\t\t\t\t\t(\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t)\t\t\t\t\t\t\t\t:\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t()\ndef\tr\t\t\t\t\t\t\t\t\t\t\t\t\t\t(\t\t\t\t\t\t\t\t\t\t\t\t\t\t)\t\t\t\t\t\t\t\t:\t\t\t\t\t\t\t\t\t\t\t\t\t\t...\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t",
-    ],
-)
-def test_sorting_whitespace_preserving_python(initial):
-    initial_count = count_whitespace(initial)
-
-    def is_interesting(tc):
-        assert count_whitespace(tc) == initial_count
-        assert Counter(tc) == Counter(initial)
-        return is_python(tc)
-
-    result = reduce_with([sort_whitespace], initial, is_interesting)
-
-    for run in runs_of_whitespace(result)[1:]:
-        assert len(run) <= 1
-
-
-def runs_of_whitespace(result):
-    whitespace_runs = []
-    i = 0
-    while i < len(result):
-        c = result[i]
-        if c not in WHITESPACE:
-            i += 1
-            continue
-        j = i + 1
-        while j < len(result) and result[j] in WHITESPACE:
-            j += 1
-        whitespace_runs.append(result[i:j])
-        i = j
-    return whitespace_runs
-
-
 def test_debracket():
     assert (
         reduce_with([debracket], b"(1 + 2) + (3 + 4)", lambda x: b"(3 + 4)" in x)