shrinkray 0.0.0__py3-none-any.whl

shrinkray/passes/patching.py

@@ -0,0 +1,280 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from random import Random
+from typing import Any, Callable, Generic, Iterable, Sequence, TypeVar, cast
+
+import trio
+
+from shrinkray.problem import ReductionProblem
+
+Seq = TypeVar("Seq", bound=Sequence[Any])
+T = TypeVar("T")
+
+PatchType = TypeVar("PatchType")
+TargetType = TypeVar("TargetType")
+
+
+class Conflict(Exception):
+    pass
+
+
+class Patches(Generic[PatchType, TargetType], ABC):
+    @property
+    @abstractmethod
+    def empty(self) -> PatchType: ...
+
+    @abstractmethod
+    def combine(self, *patches: PatchType) -> PatchType: ...
+
+    @abstractmethod
+    def apply(self, patch: PatchType, target: TargetType) -> TargetType: ...
+
+    @abstractmethod
+    def size(self, patch: PatchType) -> int: ...
+
+
+class SetPatches(Patches[frozenset[T], TargetType]):
+    def __init__(self, apply: Callable[[frozenset[T], TargetType], TargetType]):
+        self.__apply = apply
+
+    @property
+    def empty(self):
+        return frozenset()
+
+    def combine(self, *patches: frozenset[T]) -> frozenset[T]:
+        result = set()
+        for p in patches:
+            result.update(p)
+        return frozenset(result)
+
+    def apply(self, patch: frozenset[T], target: TargetType) -> TargetType:
+        return self.__apply(patch, target)
+
+    def size(self, patch: frozenset[T]) -> int:
+        return len(patch)
+
+
+class ListPatches(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(Generic[PatchType, TargetType], ABC):
+    def __init__(
+        self,
+        patches: Patches[PatchType, TargetType],
+        problem: ReductionProblem[TargetType],
+    ):
+        self.__patches = patches
+        self.__problem = problem
+
+        self.__tick = 0
+        self.__merge_queue = []
+        self.__merge_lock = trio.Lock()
+
+        self.__current_patch = self.__patches.empty
+        self.__initial_test_case = problem.current_test_case
+
+    async def try_apply_patch(self, patch: PatchType) -> bool:
+        initial_patch = self.__current_patch
+        try:
+            combined_patch = self.__patches.combine(initial_patch, patch)
+        except Conflict:
+            return False
+        if combined_patch == self.__current_patch:
+            return True
+        with_patch_applied = self.__patches.apply(
+            combined_patch, self.__initial_test_case
+        )
+        if with_patch_applied == self.__problem.current_test_case:
+            return True
+        if not await self.__problem.is_interesting(with_patch_applied):
+            return False
+        send_merge_result, receive_merge_result = trio.open_memory_channel(1)
+
+        sort_key = (self.__tick, self.__problem.sort_key(with_patch_applied))
+        self.__tick += 1
+
+        self.__merge_queue.append((sort_key, patch, send_merge_result))
+
+        async with self.__merge_lock:
+            if (
+                self.__current_patch == initial_patch
+                and len(self.__merge_queue) == 1
+                and self.__merge_queue[0][1] == patch
+                and self.__problem.sort_key(with_patch_applied)
+                <= self.__problem.sort_key(self.__problem.current_test_case)
+            ):
+                self.__current_patch = combined_patch
+                self.__merge_queue.clear()
+                return True
+
+            while self.__merge_queue:
+                base_patch = self.__current_patch
+                to_merge = len(self.__merge_queue)
+
+                async def can_merge(k):
+                    if k > to_merge:
+                        return False
+                    try:
+                        attempted_patch = self.__patches.combine(
+                            base_patch, *[p for _, p, _ in self.__merge_queue[:k]]
+                        )
+                    except Conflict:
+                        return False
+                    if attempted_patch == base_patch:
+                        return True
+                    with_patch_applied = self.__patches.apply(
+                        attempted_patch, self.__initial_test_case
+                    )
+                    if await self.__problem.is_reduction(with_patch_applied):
+                        self.__current_patch = attempted_patch
+                        return True
+                    else:
+                        return False
+
+                if await can_merge(to_merge):
+                    merged = to_merge
+                else:
+                    merged = await self.__problem.work.find_large_integer(can_merge)
+
+                for _, _, send_result in self.__merge_queue[:merged]:
+                    send_result.send_nowait(True)
+
+                assert merged <= to_merge
+                if merged < to_merge:
+                    self.__merge_queue[merged][-1].send_nowait(False)
+                    del self.__merge_queue[: merged + 1]
+                else:
+                    del self.__merge_queue[:to_merge]
+
+        # This should always have been populated during the previous merge,
+        # either by us or someone else merging.
+        return receive_merge_result.receive_nowait()
+
+
+class Direction(Enum):
+    LEFT = 0
+    RIGHT = 1
+
+
+class Completed(Exception):
+    pass
+
+
+async def apply_patches(
+    problem: ReductionProblem[TargetType],
+    patch_info: Patches[PatchType, TargetType],
+    patches: Iterable[PatchType],
+) -> None:
+    if await problem.is_interesting(
+        patch_info.apply(patch_info.combine(*patches), problem.current_test_case)
+    ):
+        return
+
+    applier = PatchApplier(patch_info, problem)
+
+    send_patches, receive_patches = trio.open_memory_channel(float("inf"))
+
+    patches = list(patches)
+    problem.work.random.shuffle(patches)
+    patches.sort(key=patch_info.size, reverse=True)
+    for patch in patches:
+        send_patches.send_nowait(patch)
+    send_patches.close()
+
+    async with trio.open_nursery() as nursery:
+        for _ in range(problem.work.parallelism):
+
+            @nursery.start_soon
+            async def _():
+                while True:
+                    try:
+                        patch = await receive_patches.receive()
+                    except trio.EndOfChannel:
+                        break
+                    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(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]]
+
+
+class Cuts(Patches[CutPatch, Seq]):
+    @property
+    def empty(self) -> CutPatch:
+        return []
+
+    def combine(self, *patches: CutPatch) -> CutPatch:
+        all_cuts: CutPatch = []
+        for p in patches:
+            all_cuts.extend(p)
+        all_cuts.sort()
+        normalized: list[list[int]] = []
+        for start, end in all_cuts:
+            if normalized and normalized[-1][-1] >= start:
+                normalized[-1][-1] = max(normalized[-1][-1], end)
+            else:
+                normalized.append([start, end])
+        return [cast(tuple[int, int], tuple(x)) for x in normalized]
+
+    def apply(self, patch: CutPatch, target: Seq) -> Seq:
+        result: list[Any] = []
+        prev = 0
+        total_deleted = 0
+        for start, end in patch:
+            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 size(self, patch: CutPatch) -> int:
+        return sum(v - u for u, v in patch)

shrinkray/passes/python.py

@@ -0,0 +1,176 @@
+from typing import Any, AnyStr, Callable
+
+import libcst
+import libcst.matchers as m
+from libcst import CSTNode, codemod
+
+from shrinkray.problem import ReductionProblem
+from shrinkray.work import NotFound
+
+
+def is_python(source: AnyStr) -> bool:
+    try:
+        libcst.parse_module(source)
+        return True
+    except (SyntaxError, UnicodeDecodeError, libcst.ParserSyntaxError, Exception):
+        return False
+
+
+Replacement = CSTNode | libcst.RemovalSentinel | libcst.FlattenSentinel[Any]
+
+
+async def libcst_transform(
+    problem: ReductionProblem[bytes],
+    matcher: m.BaseMatcherNode,
+    transformer: Callable[
+        [CSTNode],
+        Replacement,
+    ],
+) -> None:
+    class CM(codemod.VisitorBasedCodemodCommand):
+        def __init__(self, context: codemod.CodemodContext, target_index: int):
+            super().__init__(context)
+            self.target_index = target_index
+            self.current_index = 0
+            self.fired = False
+
+        # We have to have an ignore on the return type because if we don't LibCST
+        # will do some stupid bullshit with checking if the return type is correct
+        # and we use this generically in a way that makes it hard to type correctly.
+        @m.leave(matcher)
+        def maybe_change_node(self, _, updated_node):  # type: ignore
+            if self.current_index == self.target_index:
+                self.fired = True
+                return transformer(updated_node)
+            else:
+                self.current_index += 1
+                return updated_node
+
+    try:
+        module = libcst.parse_module(problem.current_test_case)
+    except Exception:
+        return
+
+    context = codemod.CodemodContext()
+
+    counting_mod = CM(context, -1)
+    counting_mod.transform_module(module)
+
+    n = counting_mod.current_index + 1
+
+    async def can_apply(i: int) -> bool:
+        nonlocal n
+        if i >= n:
+            return False
+        initial_test_case = problem.current_test_case
+        try:
+            module = libcst.parse_module(initial_test_case)
+        except libcst.ParserSyntaxError:
+            n = 0
+            return False
+
+        codemod_i = CM(context, i)
+        try:
+            transformed = codemod_i.transform_module(module)
+        except libcst.CSTValidationError:
+            return False
+        except TypeError as e:
+            if "does not allow for it" in e.args[0]:
+                return False
+            raise
+
+        if not codemod_i.fired:
+            n = i
+            return False
+
+        transformed_test_case = transformed.code.encode(transformed.encoding)
+
+        if problem.sort_key(transformed_test_case) >= problem.sort_key(
+            initial_test_case
+        ):
+            return False
+
+        return await problem.is_interesting(transformed_test_case)
+
+    i = 0
+    while i < n:
+        try:
+            i = await problem.work.find_first_value(range(i, n), can_apply)
+        except NotFound:
+            break
+
+
+async def lift_indented_constructs(problem: ReductionProblem[bytes]) -> None:
+    await libcst_transform(
+        problem,
+        m.OneOf(m.While(), m.If(), m.Try()),
+        lambda x: x.with_changes(orelse=None),
+    )
+
+    await libcst_transform(
+        problem,
+        m.OneOf(m.While(), m.If(), m.Try(), m.With()),
+        lambda x: libcst.FlattenSentinel(x.body.body),  # type: ignore
+    )
+
+
+async def delete_statements(problem: ReductionProblem[bytes]) -> None:
+    await libcst_transform(
+        problem,
+        m.SimpleStatementLine(),
+        lambda x: libcst.RemoveFromParent(),  # type: ignore
+    )
+
+
+async def replace_statements_with_pass(problem: ReductionProblem[bytes]) -> None:
+    await libcst_transform(
+        problem,
+        m.SimpleStatementLine(),
+        lambda x: x.with_changes(body=[libcst.Pass()]),  # type: ignore
+    )
+
+
+ELLIPSIS_STATEMENT = libcst.parse_statement("...")
+
+
+async def replace_bodies_with_ellipsis(problem: ReductionProblem[bytes]) -> None:
+    await libcst_transform(
+        problem,
+        m.IndentedBlock(),
+        lambda x: x.with_changes(body=[ELLIPSIS_STATEMENT]),  # type: ignore
+    )
+
+
+async def strip_annotations(problem: ReductionProblem[bytes]) -> None:
+    await libcst_transform(
+        problem,
+        m.FunctionDef(),
+        lambda x: x.with_changes(returns=None),
+    )
+    await libcst_transform(
+        problem,
+        m.Param(),
+        lambda x: x.with_changes(annotation=None),
+    )
+    await libcst_transform(
+        problem,
+        m.AnnAssign(),
+        lambda x: (
+            libcst.Assign(
+                targets=[libcst.AssignTarget(target=x.target)],
+                value=x.value,
+                semicolon=x.semicolon,
+            )
+            if x.value
+            else libcst.RemoveFromParent()
+        ),
+    )
+
+
+PYTHON_PASSES = [
+    replace_bodies_with_ellipsis,
+    strip_annotations,
+    lift_indented_constructs,
+    delete_statements,
+    replace_statements_with_pass,
+]

shrinkray/passes/sat.py

@@ -0,0 +1,176 @@
+from shrinkray.passes.definitions import Format, ParseError, ReductionPass
+from shrinkray.passes.patching import SetPatches, apply_patches
+from shrinkray.passes.sequences import delete_elements
+from shrinkray.problem import ReductionProblem
+
+Clause = list[int]
+SAT = list[Clause]
+
+
+class _DimacsCNF(Format[bytes, SAT]):
+    @property
+    def name(self) -> str:
+        return "DimacsCNF"
+
+    def parse(self, input: bytes) -> SAT:
+        try:
+            contents = input.decode("utf-8")
+        except UnicodeDecodeError as e:
+            raise ParseError(*e.args)
+        clauses = []
+        for line in contents.splitlines():
+            line = line.strip()
+            if line.startswith("c"):
+                continue
+            if line.startswith("p"):
+                continue
+            if not line.strip():
+                continue
+            try:
+                clause = list(map(int, line.strip().split()))
+            except ValueError as e:
+                raise ParseError(*e.args)
+            if clause[-1] != 0:
+                raise ParseError(f"{line} did not end with 0")
+            clause.pop()
+            clauses.append(clause)
+        if not clauses:
+            raise ParseError("No clauses found")
+        return clauses
+
+    def dumps(self, input: SAT) -> bytes:
+        n_variables = max(abs(literal) for clause in input for literal in clause)
+
+        parts = [f"p cnf {n_variables} {len(input)}"]
+
+        for c in input:
+            parts.append(" ".join(map(repr, list(c) + [0])))
+
+        return "\n".join(parts).encode("utf-8")
+
+
+DimacsCNF = _DimacsCNF()
+
+
+async def renumber_variables(problem: ReductionProblem[SAT]):
+    renumbering = {}
+
+    def renumber(l):
+        if l < 0:
+            return -renumber(-l)
+        try:
+            return renumbering[l]
+        except KeyError:
+            pass
+        result = len(renumbering) + 1
+        renumbering[l] = result
+        return result
+
+    renumbered = [
+        [renumber(literal) for literal in clause]
+        for clause in problem.current_test_case
+    ]
+
+    await problem.is_interesting(renumbered)
+
+
+async def flip_literal_signs(problem: ReductionProblem[SAT]):
+    seen_variables = set()
+    target = problem.current_test_case
+    for i in range(len(target)):
+        for j, v in enumerate(target[i]):
+            if abs(v) not in seen_variables and v < 0:
+                attempt = []
+                for clause in target:
+                    new_clause = []
+                    for literal in clause:
+                        if abs(literal) == abs(v):
+                            new_clause.append(-literal)
+                        else:
+                            new_clause.append(literal)
+                    attempt.append(new_clause)
+                if await problem.is_interesting(attempt):
+                    target = attempt
+            seen_variables.add(abs(v))
+
+
+async def remove_redundant_clauses(problem: ReductionProblem[SAT]):
+    attempt = []
+    seen = set()
+    for clause in problem.current_test_case:
+        if len(set(map(abs, clause))) < len(set(clause)):
+            continue
+        key = tuple(clause)
+        if key in seen:
+            continue
+        seen.add(key)
+        attempt.append(clause)
+    await problem.is_interesting(attempt)
+
+
+def literals_in(sat: SAT) -> frozenset[int]:
+    return frozenset({literal for clause in sat for literal in clause})
+
+
+async def delete_literals(problem: ReductionProblem[SAT]):
+    def remove_literals(literals: frozenset[int], sat: SAT) -> SAT:
+        result = []
+        for clause in sat:
+            new_clause = [v for v in clause if v not in literals]
+            if new_clause:
+                result.append(new_clause)
+        return result
+
+    await apply_patches(
+        problem,
+        SetPatches(remove_literals),
+        [frozenset({v}) for v in literals_in(problem.current_test_case)],
+    )
+
+
+async def merge_variables(problem: ReductionProblem[SAT]):
+    i = 0
+    j = 1
+    while True:
+        variables = sorted({abs(l) for c in problem.current_test_case for l in c})
+        if j >= len(variables):
+            i += 1
+            j = i + 1
+        if j >= len(variables):
+            return
+
+        target = variables[i]
+        to_replace = variables[j]
+
+        new_clauses = []
+        for c in problem.current_test_case:
+            c = set(c)
+            if to_replace in c:
+                c.discard(to_replace)
+                c.add(target)
+            if -to_replace in c:
+                c.discard(-to_replace)
+                c.add(-target)
+            if len(set(map(abs, c))) < len(c):
+                continue
+            new_clauses.append(sorted(c))
+
+        assert new_clauses != problem.current_test_case
+        await problem.is_interesting(new_clauses)
+        if new_clauses != problem.current_test_case:
+            j += 1
+
+
+async def sort_clauses(problem: ReductionProblem[SAT]):
+    await problem.is_interesting(sorted(map(sorted, problem.current_test_case)))
+
+
+SAT_PASSES: list[ReductionPass[SAT]] = [
+    sort_clauses,
+    renumber_variables,
+    flip_literal_signs,
+    remove_redundant_clauses,
+    delete_elements,
+    delete_literals,
+    merge_variables,
+]

shrinkray/passes/sequences.py

@@ -0,0 +1,69 @@
+from collections import defaultdict
+from typing import Any, Sequence, TypeVar
+
+from shrinkray.passes.definitions import ReductionPass
+from shrinkray.passes.patching import CutPatch, Cuts, apply_patches
+from shrinkray.problem import ReductionProblem
+
+Seq = TypeVar("Seq", bound=Sequence[Any])
+
+
+async def delete_elements(problem: ReductionProblem[Seq]) -> None:
+    await apply_patches(
+        problem, Cuts(), [[(i, i + 1)] for i in range(len(problem.current_test_case))]
+    )
+
+
+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(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(min_block: int, max_block: int) -> ReductionPass[Seq]:
+    async def apply(problem: ReductionProblem[Seq]) -> None:
+        n = len(problem.current_test_case)
+        if n <= min_block:
+            return
+        blocks = [
+            [(i, i + block_size)]
+            for block_size in range(min_block, max_block + 1)
+            for offset in range(block_size)
+            for i in range(offset, n, block_size)
+            if i + block_size <= n
+        ]
+        await apply_patches(problem, Cuts(), blocks)
+
+    apply.__name__ = f"block_deletion({min_block}, {max_block})"
+    return apply
+
+
+async def delete_duplicates(problem: ReductionProblem[Seq]) -> None:
+    index: dict[int, list[int]] = defaultdict(list)
+
+    for i, c in enumerate(problem.current_test_case):
+        index[c].append(i)
+
+    cuts: list[CutPatch] = []
+
+    for ix in index.values():
+        if len(ix) > 1:
+            cuts.append([(i, i + 1) for i in ix])
+    await apply_patches(problem, Cuts(), cuts)