shrinkray 25.12.27.3__py3-none-any.whl → 25.12.28.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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.dist-info → shrinkray-25.12.28.0.dist-info}/METADATA

@@ -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.28.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+shrinkray/__init__.py,sha256=b5MvcvhsEGYya3GRXNbCJAlAL5IZHSsETLK_vtfmXRY,18
+shrinkray/__main__.py,sha256=HuDZFXgD9LH3XPBK2QBvP4YkyTFJvduK9-PVtz9fKpk,11762
+shrinkray/cli.py,sha256=1-qjaIchyCDd-YCdGWtK7q9j9qr6uX6AqtwW8m5QCQg,1697
+shrinkray/formatting.py,sha256=tXCGnhJn-WJGpHMaLHRCAXK8aKJBbrOdiW9QGERrQEk,3121
+shrinkray/problem.py,sha256=_edENYk8OC5o_2ng0WZrhIfilhlY5IuOrqt0qWBZAuM,25979
+shrinkray/process.py,sha256=-eP8h5X0ESbkcTic8FFEzkd4-vwaZ0YI5tLxUR25L8U,1599
+shrinkray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shrinkray/reducer.py,sha256=8CF_SxkfVMBxiikQKwv-rlrQawTLhQxy6QnVwIWWiws,18601
+shrinkray/state.py,sha256=V5vUyBKXudLoMe3TvGJwWf6EDzdVr2TRrmdNyU13qio,29565
+shrinkray/tui.py,sha256=Ovd6Kbk_cmOYJlwnjEyl6ka_2g1qJAtwxojh5CWEzNA,33001
+shrinkray/ui.py,sha256=xuDUwU-MM3AetvwUB7bfzav0P_drUsBrKFPhON_Nr-k,2251
+shrinkray/validation.py,sha256=piBCO-k9he_id6TWC4EHMK3GfuyPqRcNfkNJPVjxEaU,13366
+shrinkray/work.py,sha256=GEZ14Kk3bvwUxAnACvY-wom2lVWaGrELMNxrDjv03dk,8110
+shrinkray/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shrinkray/passes/bytes.py,sha256=2Xw6WI3d3MNJATQKpS77qywdxINlwiHt__dIdh8LCVE,20230
+shrinkray/passes/clangdelta.py,sha256=0CYbBiGBpD2wlOpefe_uJnea1YU2-UMfLxKi1KPcxpY,7678
+shrinkray/passes/definitions.py,sha256=TDDPimp7DE60xgidAE11npt2KicQAEi0UydIzjS9VHw,2469
+shrinkray/passes/genericlanguages.py,sha256=QDUIDJbzFsAjHzTWH-sB-ioB2NhBPBtZOk8Q5ZwxA54,9859
+shrinkray/passes/json.py,sha256=3EcM7bmseFZaIPUN2N8c9CZYQoKVHnYfhGG1RKrrItg,2458
+shrinkray/passes/patching.py,sha256=Fo04O0hVMBLFuIP704LPCJrbjU1ITHr4lCt2HrvMsOc,7449
+shrinkray/passes/python.py,sha256=3WN1lZTf5oVL8FCTGomhrCuE04wIX9ocKcmFV86NMZA,6875
+shrinkray/passes/sat.py,sha256=OboY6jsKf6lph3pAFh535plvhNOVzEF8HJ66WEqsNm4,19483
+shrinkray/passes/sequences.py,sha256=-5ajmMeHnS7onjjppbxLiP0F6mRSqiFI5DspBTj2x_M,2206
+shrinkray/subprocess/__init__.py,sha256=qxZ19Nzizbm7H0MkKL38OqfP7U-VuOAvaqBVkmHFivY,375
+shrinkray/subprocess/client.py,sha256=abBkrXaJcA6cd3l_avPuteO_kYnjU5IRG7VtlmiAJgE,9428
+shrinkray/subprocess/protocol.py,sha256=di4vXIFcCSs2ej1E4Y3WeYXsNoo4VsBjEIeogf5AYQY,6336
+shrinkray/subprocess/worker.py,sha256=0D719AHSF-oL5iifG6x4xYeUCMxEUZ_QXrDrogC901U,21238
+shrinkray-25.12.28.0.dist-info/licenses/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
+shrinkray-25.12.28.0.dist-info/METADATA,sha256=pwliGh5xlyr_LLxhuqsoCnl_pl77NYLaB8EqCIt4iBU,7600
+shrinkray-25.12.28.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shrinkray-25.12.28.0.dist-info/entry_points.txt,sha256=wIZvnGyOdVeaLTiv2klnSyTe-EKkkwn4SwHh9bmJ7qk,104
+shrinkray-25.12.28.0.dist-info/top_level.txt,sha256=fLif8-rFoFOnf5h8-vs3ECkKNWQopTQh3xvl1s7pchQ,10
+shrinkray-25.12.28.0.dist-info/RECORD,,

shrinkray/display.py

@@ -1,75 +0,0 @@
-"""Display utilities for shrink ray."""
-
-import shutil
-from collections.abc import Iterable
-
-from binaryornot.check import is_binary_string  # type: ignore[import-not-found]
-
-
-def get_terminal_size() -> tuple[int, int]:
-    """Get terminal size, with sensible fallbacks.
-
-    Returns:
-        (columns, lines) tuple. Defaults to (80, 24) if terminal size
-        cannot be determined.
-    """
-    size = shutil.get_terminal_size(fallback=(80, 24))
-    return (size.columns, size.lines)
-
-
-def to_lines(test_case: bytes) -> list[str]:
-    """Convert a test case to displayable lines."""
-    result = []
-    for line in test_case.split(b"\n"):
-        if is_binary_string(line):
-            result.append(line.hex())
-        else:
-            try:
-                result.append(line.decode("utf-8"))
-            except UnicodeDecodeError:
-                result.append(line.hex())
-    return result
-
-
-def to_blocks(test_case: bytes, block_size: int | None = None) -> list[str]:
-    """Convert a test case to hex blocks for display.
-
-    Args:
-        test_case: The bytes to convert
-        block_size: Number of bytes per block. If None, automatically
-                    calculated from terminal width (each byte becomes 2 hex chars).
-    """
-    if block_size is None:
-        columns, _ = get_terminal_size()
-        # Each byte becomes 2 hex chars, leave some margin
-        block_size = max(1, (columns - 4) // 2)
-    return [
-        test_case[i : i + block_size].hex()
-        for i in range(0, len(test_case), block_size)
-    ]
-
-
-def format_diff(diff: Iterable[str], max_lines: int | None = None) -> str:
-    """Format a diff for display, truncating if too long.
-
-    Args:
-        diff: Iterable of diff lines
-        max_lines: Maximum number of lines to include. If None, uses
-                   terminal height multiplied by a factor to allow scrolling
-                   through substantial context.
-    """
-    if max_lines is None:
-        _, lines = get_terminal_size()
-        # Allow multiple screenfuls of context for scrolling
-        max_lines = max(lines * 20, 100)
-    results = []
-    start_writing = False
-    for line in diff:
-        if not start_writing and line.startswith("@@"):
-            start_writing = True
-        if start_writing:
-            results.append(line)
-            if len(results) > max_lines:
-                results.append("...")
-                break
-    return "\n".join(results)

shrinkray-25.12.27.3.dist-info/RECORD

@@ -1,34 +0,0 @@
-shrinkray/__init__.py,sha256=b5MvcvhsEGYya3GRXNbCJAlAL5IZHSsETLK_vtfmXRY,18
-shrinkray/__main__.py,sha256=HuDZFXgD9LH3XPBK2QBvP4YkyTFJvduK9-PVtz9fKpk,11762
-shrinkray/cli.py,sha256=1-qjaIchyCDd-YCdGWtK7q9j9qr6uX6AqtwW8m5QCQg,1697
-shrinkray/display.py,sha256=WYN05uqmUVpZhwi2pxr1U-wLHWZ9KiL0RUlTCBJ1N3E,2430
-shrinkray/formatting.py,sha256=tXCGnhJn-WJGpHMaLHRCAXK8aKJBbrOdiW9QGERrQEk,3121
-shrinkray/problem.py,sha256=_edENYk8OC5o_2ng0WZrhIfilhlY5IuOrqt0qWBZAuM,25979
-shrinkray/process.py,sha256=-eP8h5X0ESbkcTic8FFEzkd4-vwaZ0YI5tLxUR25L8U,1599
-shrinkray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shrinkray/reducer.py,sha256=t2BBjq-EZ0qBbsez4ep0tFYCkDT8RwKYnjJ2fRsXubg,20096
-shrinkray/state.py,sha256=a8Xq7IQwLz7CyZ58zU0Z91uoglgPJmhQUvbcdgsIoKk,29593
-shrinkray/tui.py,sha256=Ovd6Kbk_cmOYJlwnjEyl6ka_2g1qJAtwxojh5CWEzNA,33001
-shrinkray/ui.py,sha256=xuDUwU-MM3AetvwUB7bfzav0P_drUsBrKFPhON_Nr-k,2251
-shrinkray/validation.py,sha256=piBCO-k9he_id6TWC4EHMK3GfuyPqRcNfkNJPVjxEaU,13366
-shrinkray/work.py,sha256=GEZ14Kk3bvwUxAnACvY-wom2lVWaGrELMNxrDjv03dk,8110
-shrinkray/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shrinkray/passes/bytes.py,sha256=U1sNAuqUlsaLpRSJuS9X4H7S2jOiilTUIIE9-WjSd4k,23967
-shrinkray/passes/clangdelta.py,sha256=t9EQ_kc159HRs48JwB5JvlJCsiCscrZgf2nhHCZRZX0,8419
-shrinkray/passes/definitions.py,sha256=TDDPimp7DE60xgidAE11npt2KicQAEi0UydIzjS9VHw,2469
-shrinkray/passes/genericlanguages.py,sha256=ZqTfEHUTRbkm6PiTkBc_y3Q5Q0MJAnibNEiuKDOhiS0,10432
-shrinkray/passes/json.py,sha256=FydtjpVD3lMjp9OEwv5mu8CAz96ofGxIZOzt9o6eLUA,2586
-shrinkray/passes/patching.py,sha256=1uOTir3IbywKmsg6IIhSnxHFovZTdUCS-8PSwzgza00,8936
-shrinkray/passes/python.py,sha256=3WN1lZTf5oVL8FCTGomhrCuE04wIX9ocKcmFV86NMZA,6875
-shrinkray/passes/sat.py,sha256=OboY6jsKf6lph3pAFh535plvhNOVzEF8HJ66WEqsNm4,19483
-shrinkray/passes/sequences.py,sha256=jCK1fWBxCz79u7JWSps9wf7Yru7W_FAsJwdgg--CLxU,3040
-shrinkray/subprocess/__init__.py,sha256=FyV2y05uwQ1RTZGwREI0aAVaLX1jiwRcWsdsksFmdbM,451
-shrinkray/subprocess/client.py,sha256=abBkrXaJcA6cd3l_avPuteO_kYnjU5IRG7VtlmiAJgE,9428
-shrinkray/subprocess/protocol.py,sha256=fbY29q-j98KnAuZJ1Y_ARoi7BskkUu37SoybwVWb-pA,6636
-shrinkray/subprocess/worker.py,sha256=IBAXZq3E27bTuN9kHGgU5xhU6E8m_5-Ioz1dubVTuN8,21449
-shrinkray-25.12.27.3.dist-info/licenses/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
-shrinkray-25.12.27.3.dist-info/METADATA,sha256=BUSNccYFT8TdtojoQHdt-YR9DEVtjsG8fNvlybnRsB0,7600
-shrinkray-25.12.27.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shrinkray-25.12.27.3.dist-info/entry_points.txt,sha256=wIZvnGyOdVeaLTiv2klnSyTe-EKkkwn4SwHh9bmJ7qk,104
-shrinkray-25.12.27.3.dist-info/top_level.txt,sha256=fLif8-rFoFOnf5h8-vs3ECkKNWQopTQh3xvl1s7pchQ,10
-shrinkray-25.12.27.3.dist-info/RECORD,,