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

shrinkray/ui.py

@@ -0,0 +1,72 @@
+"""UI abstractions for shrink ray."""
+
+from abc import ABC
+from typing import TYPE_CHECKING
+
+import humanize
+import trio
+from attrs import define
+
+
+if TYPE_CHECKING:
+    from shrinkray.problem import BasicReductionProblem
+    from shrinkray.state import ShrinkRayState
+
+
+@define(slots=False)
+class ShrinkRayUI[TestCase](ABC):
+    """Base class for shrink ray UI implementations."""
+
+    state: "ShrinkRayState[TestCase]"
+
+    @property
+    def reducer(self):
+        return self.state.reducer
+
+    @property
+    def problem(self) -> "BasicReductionProblem":
+        return self.reducer.target  # type: ignore
+
+    def install_into_nursery(self, nursery: trio.Nursery):  # noqa: B027
+        """Install any background tasks into the nursery.
+
+        Subclasses may override this to add tasks that run alongside reduction.
+        The default implementation does nothing.
+        """
+
+    async def run(self, nursery: trio.Nursery):  # noqa: B027
+        """Run the UI update loop.
+
+        Subclasses may override this to display progress or status updates.
+        The default implementation does nothing.
+        """
+
+
+class BasicUI[TestCase](ShrinkRayUI[TestCase]):
+    """Simple text-based UI for non-interactive use."""
+
+    async def run(self, nursery: trio.Nursery):
+        initial = self.state.initial
+        size = self.state.problem.size
+        print(
+            f"Starting reduction. Initial test case size: "
+            f"{humanize.naturalsize(size(initial))}",
+            flush=True,
+        )
+        prev_reduction = 0
+        while True:
+            initial = self.state.initial
+            current = self.state.problem.current_test_case
+            size = self.state.problem.size
+            reduction = size(initial) - size(current)
+            if reduction > prev_reduction:
+                print(
+                    f"Reduced test case to {humanize.naturalsize(size(current))} "
+                    f"(deleted {humanize.naturalsize(reduction)}, "
+                    f"{humanize.naturalsize(reduction - prev_reduction)} since last time)",
+                    flush=True,
+                )
+                prev_reduction = reduction
+                await trio.sleep(5)
+            else:
+                await trio.sleep(0.1)

shrinkray/work.py

@@ -1,14 +1,30 @@
+"""Parallelism coordination and work management.
+
+This module provides WorkContext, which manages parallel execution of
+reduction work using Trio. The key insight is that test-case reduction
+benefits from parallelism even though results are sequential: we can
+speculatively test multiple candidates and keep the first success.
+
+Key concepts:
+- Lazy evaluation: Don't compute results until needed
+- Backpressure: Limit in-flight work to avoid memory exhaustion
+- Order preservation: Results come out in input order for reproducibility
+"""
+
 import heapq
+from collections.abc import Awaitable, Callable, Sequence
 from contextlib import asynccontextmanager
 from enum import IntEnum
 from itertools import islice
 from random import Random
-from typing import Awaitable, Callable, Optional, Sequence, TypeVar
+from typing import TypeVar
 
 import trio
 
 
 class Volume(IntEnum):
+    """Logging verbosity levels."""
+
     quiet = 0
     normal = 1
     verbose = 2
@@ -19,16 +35,26 @@ S = TypeVar("S")
 T = TypeVar("T")
 
 
-TICK_FREQUENCY = 0.05
+class WorkContext:
+    """Coordinates parallel work execution for reduction.
 
+    WorkContext provides methods for parallel map, filter, and search
+    operations that are tailored for test-case reduction:
 
-class WorkContext:
-    """A grab bag of useful tools for 'doing work'. Manages randomness,
-    logging, concurrency."""
+    - map(): Lazy parallel map with backpressure
+    - filter(): Parallel filter, yielding matching items
+    - find_first_value(): Find first item satisfying a predicate
+    - find_large_integer(): Binary search for largest valid integer
+
+    The parallelism is speculative: multiple candidates are tested
+    concurrently, but only one result "wins". This trades CPU for
+    wall-clock time, which is usually worthwhile when interestingness
+    tests are slow.
+    """
 
     def __init__(
         self,
-        random: Optional[Random] = None,
+        random: Random | None = None,
         parallelism: int = 1,
         volume: Volume = Volume.normal,
     ):
@@ -61,6 +87,7 @@ class WorkContext:
                         await send.send(await f(x))
                         break
                     else:
+                        send.close()
                         return
 
                     n = 2
@@ -98,6 +125,7 @@ class WorkContext:
                     async for x, v in results:
                         if v:
                             await send.send(x)
+                    send.close()
 
             yield receive
             nursery.cancel_scope.cancel()

{shrinkray-0.0.0.dist-info → shrinkray-25.12.26.0.dist-info}/METADATA

@@ -1,29 +1,41 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: shrinkray
-Version: 0.0.0
+Version: 25.12.26.0
 Summary: Shrink Ray
-Home-page: https://github.com/DRMacIver/shrinkray
+Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
-Author: David R. MacIver
-Author-email: david@drmaciver.com
-Requires-Python: >=3.12,<4.0
-Classifier: Development Status :: 3 - Alpha
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: binaryornot (>=0.4.4,<0.5.0)
-Requires-Dist: chardet (>=5.2.0,<6.0.0)
-Requires-Dist: click (>=8.0.1)
-Requires-Dist: exceptiongroup (>=1.2.0,<2.0.0)
-Requires-Dist: humanize (>=4.9.0,<5.0.0)
-Requires-Dist: libcst (>=1.1.0,<2.0.0)
-Requires-Dist: trio (>=0.28.0,<0.29.0)
-Requires-Dist: urwid (>=2.2.3,<3.0.0)
-Project-URL: Changelog, https://github.com/DRMacIver/shrinkray/releases
-Project-URL: Documentation, https://shrinkray.readthedocs.io
+Project-URL: Homepage, https://github.com/DRMacIver/shrinkray
 Project-URL: Repository, https://github.com/DRMacIver/shrinkray
+Project-URL: Documentation, https://shrinkray.readthedocs.io
+Project-URL: Changelog, https://github.com/DRMacIver/shrinkray/releases
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.1
+Requires-Dist: chardet>=5.2.0
+Requires-Dist: trio>=0.28.0
+Requires-Dist: textual>=0.47.0
+Requires-Dist: humanize>=4.9.0
+Requires-Dist: libcst>=1.1.0
+Requires-Dist: exceptiongroup>=1.2.0
+Requires-Dist: binaryornot>=0.4.4
+Requires-Dist: black
+Provides-Extra: dev
+Requires-Dist: coverage>=7.13.0; extra == "dev"
+Requires-Dist: hypothesis>=6.92.1; extra == "dev"
+Requires-Dist: hypothesmith>=0.3.1; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-trio; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-textual-snapshot; extra == "dev"
+Requires-Dist: coverage[toml]; extra == "dev"
+Requires-Dist: pygments; extra == "dev"
+Requires-Dist: basedpyright; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pexpect>=4.9.0; extra == "dev"
+Requires-Dist: pyte>=0.8.2; extra == "dev"
+Dynamic: license-file
 
 # Shrink Ray
 
@@ -77,21 +89,27 @@ Most test-case reducers only work well on a few formats. Shrink Ray is designed
 
 It's designed to be highly parallel, and work with a very wide variety of formats, through a mix of good generic algorithms and format-specific reduction passes.
 
-Currently shrink ray is a "prerelease" version in the sense that there is no official release yet and you're expected to just run off main (don't worry this is easy to do), as it's a bit experimental.
+## Versioning and Releases
 
-That being said this probably doesn't matter that much for the question of whether to use it. It's in the nature of test-case reduction that it doesn't matter all that much if it's bad, because it's still going to do a bunch of work that you didn't have to do by hand. Try it out, see if it works. If it doesn't, please tell me and I'll make it work better.
+Shrink Ray uses calendar versioning (calver) in the format YY.M.D.N (e.g., 25.12.26.0 for the first release on December 26, 2025, 25.12.26.1 for the second, etc.).
+
+New releases are published automatically when changes are pushed to main if there are any changes to the source code or pyproject.toml since the previous release.
+
+Shrinkray makes no particularly strong backwards compatibility guarantees. I aim to keep its behaviour relatively stable between releases, but for example will not be particularly shy about dropping old versions of Python or adding new dependencies. The basic workflow of running a simple reduction will rarely, if ever, change, but the UI is likely to be continuously evolving for some time.
 
 ## Installation
 
-Shrink Ray requires Python 3.12 or later, and can be installed using pip.
+Shrink Ray requires Python 3.12 or later, and can be installed using pip or uv like any other python package.
 
-There is currently no official release for shrink ray, and I recommend running off main. You can install it as follows:
+You can install the latest release from PyPI or run directly from the main branch:
 
 ```
+pipx install shrinkray
+# or
 pipx install git+https://github.com/DRMacIver/shrinkray.git
 ```
 
-(if you don't have or want [pipx](https://pypa.github.io/pipx/) you could also do this with pip and it would work fine)
+(if you don't have or want [pipx](https://pypa.github.io/pipx/) you could also do this with pip or `uv pip` and it would work fine)
 
 Shrink Ray requires Python 3.12 or later and won't work on earlier versions. If everything is working correctly, it should refuse to install
 on versions it's incompatible with. If you do not have Python 3.12 installed, I recommend [pyenv](https://github.com/pyenv/pyenv) for managing
@@ -167,4 +185,3 @@ Shrink Ray is something of a labour of love - I wanted to have a tool that actua
 
 That being said, it is first and foremost designed to be a useful tool for practical engineering problems.
 If you find it useful as such, please [consider sponsoring my development of it](https://github.com/sponsors/DRMacIver).
-

shrinkray-25.12.26.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+shrinkray/__init__.py,sha256=b5MvcvhsEGYya3GRXNbCJAlAL5IZHSsETLK_vtfmXRY,18
+shrinkray/__main__.py,sha256=sRYLrG-7FMa-y067JyYmLZMOkO2FJ2V-BenxqtBwQj0,10887
+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=Kp7QN10E4tzjdpoqJve8_RT26VpywzQwY0gX2VkBGCo,17277
+shrinkray/process.py,sha256=-eP8h5X0ESbkcTic8FFEzkd4-vwaZ0YI5tLxUR25L8U,1599
+shrinkray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shrinkray/reducer.py,sha256=66Q5BjTLKamO2M04i2CSrbThp7PyGTRu63_ueQnjc7g,19849
+shrinkray/state.py,sha256=_-gyAkUm0vEdF1U0Fz_Deykj-kY2u3nGn3X6BfH3viA,22371
+shrinkray/tui.py,sha256=HtvqimSr1r7IX_fukRsCsVxyhEdyj2W-HLqjVATt1eM,31235
+shrinkray/ui.py,sha256=xuDUwU-MM3AetvwUB7bfzav0P_drUsBrKFPhON_Nr-k,2251
+shrinkray/work.py,sha256=DXeqJTB_G8r7e8vrsMW2J56CJ-nhgymKBH55DT8SXs8,7901
+shrinkray/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shrinkray/passes/bytes.py,sha256=pX2kBeH38SM4j55f8bNF_2PVBCDo6XdUj73EvOFH9f8,23904
+shrinkray/passes/clangdelta.py,sha256=t9EQ_kc159HRs48JwB5JvlJCsiCscrZgf2nhHCZRZX0,8419
+shrinkray/passes/definitions.py,sha256=WEYtcWOBv7ghZRUtJWBxHRU3SnO000EFohfAD4le7KM,4267
+shrinkray/passes/genericlanguages.py,sha256=qbTuJgUieHqWtf7cly2tm0qdbrVXzVoWcAnFo7fny94,10400
+shrinkray/passes/json.py,sha256=AcmroHgb38Aa3aApwcuYNzmyya_vnCi2RFSVqomiDg8,2586
+shrinkray/passes/patching.py,sha256=1uOTir3IbywKmsg6IIhSnxHFovZTdUCS-8PSwzgza00,8936
+shrinkray/passes/python.py,sha256=3WN1lZTf5oVL8FCTGomhrCuE04wIX9ocKcmFV86NMZA,6875
+shrinkray/passes/sat.py,sha256=2FGMM4rh4AX1BVEbry082C4aLCOEOXlfr3exHbxYgSQ,19514
+shrinkray/passes/sequences.py,sha256=jCK1fWBxCz79u7JWSps9wf7Yru7W_FAsJwdgg--CLxU,3040
+shrinkray/subprocess/__init__.py,sha256=FyV2y05uwQ1RTZGwREI0aAVaLX1jiwRcWsdsksFmdbM,451
+shrinkray/subprocess/client.py,sha256=xSFqm5UyQT0WJ5aBVVkuiWDsHjZYv7RqjgrjjyX0rK0,9269
+shrinkray/subprocess/protocol.py,sha256=LuHl0IkKpDzYhAGZz_EiTHNqDNq_v1ozg5aUSl7UzE4,6203
+shrinkray/subprocess/worker.py,sha256=MbubmnuXNFxD_SRKdiFDkGhdkCEgRxdn0tPN0HoJpyk,18998
+shrinkray-25.12.26.0.dist-info/licenses/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
+shrinkray-25.12.26.0.dist-info/METADATA,sha256=ywZp_Jeav917ikM3SPZ3MlchAgF0udIIffGzIJf9pmU,9628
+shrinkray-25.12.26.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shrinkray-25.12.26.0.dist-info/entry_points.txt,sha256=wIZvnGyOdVeaLTiv2klnSyTe-EKkkwn4SwHh9bmJ7qk,104
+shrinkray-25.12.26.0.dist-info/top_level.txt,sha256=fLif8-rFoFOnf5h8-vs3ECkKNWQopTQh3xvl1s7pchQ,10
+shrinkray-25.12.26.0.dist-info/RECORD,,

{shrinkray-0.0.0.dist-info → shrinkray-25.12.26.0.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

shrinkray-25.12.26.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+shrinkray = shrinkray.__main__:main
+shrinkray-worker = shrinkray.__main__:worker_main

shrinkray-25.12.26.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+shrinkray

shrinkray/learning.py

@@ -1,221 +0,0 @@
-import hashlib
-import os
-import random
-import re
-import site
-import subprocess
-import sys
-from glob import glob
-from typing import Awaitable, Callable
-
-import trio
-from attrs import define
-
-from shrinkray.problem import BasicReductionProblem
-from shrinkray.reducer import ShrinkRay
-from shrinkray.work import WorkContext
-
-WHITESPACE = re.compile(rb"\s+")
-
-
-def whitespace_normalize(s):
-    return WHITESPACE.sub(b" ", s).strip()
-
-
-def threshold_value(seed: bytes, test_case: bytes) -> float:
-    return random.Random(hashlib.sha1(seed + b":" + test_case).digest()).random()
-
-
-@define
-class RandomInterestingnessTest:
-    seed: bytes
-    threshold: float
-    key_substring: bytes
-    base_interestingness: Callable[[bytes], Awaitable[bool]]
-
-    async def __call__(self, test_case: bytes) -> bool:
-        if threshold_value(self.seed, test_case) > self.threshold:
-            await trio.lowlevel.checkpoint()
-            return False
-        normalized = whitespace_normalize(test_case)
-        if self.key_substring not in normalized:
-            await trio.lowlevel.checkpoint()
-            return False
-        return await self.base_interestingness(test_case)
-
-
-class CouldNotLearn(Exception):
-    pass
-
-
-class CorpusExplorer:
-    def __init__(
-        self,
-        is_interesting: Callable[[bytes], Awaitable[bool]],
-        corpus: list[str],
-        parallelism=os.cpu_count(),
-    ):
-        self.__is_interesting = is_interesting
-        self.__is_interesting_cache = {}
-        self.__corpus_files = [t for t in corpus if os.stat(t).st_size > 0]
-        self.__corpus_data = []
-        self.__limit = trio.CapacityLimiter(parallelism)
-        self.__wait_for_me = object()
-        self.__random = random.Random()
-        self.__parallelism = parallelism
-
-    async def is_interesting(self, tc):
-        try:
-            result = self.__is_interesting_cache[tc]
-            if result != self.__wait_for_me:
-                await trio.lowlevel.checkpoint()
-                return result
-            while result == self.__wait_for_me:
-                await trio.sleep(0.01)
-                result = self.__is_interesting_cache[tc]
-            assert result is not self.__wait_for_me
-            return result
-        except KeyError:
-            self.__is_interesting_cache[tc] = self.__wait_for_me
-            async with self.__limit:
-                result = await self.__is_interesting(tc)
-            self.__is_interesting_cache[tc] = result
-            return result
-
-    async def random_corpus_member(self):
-        return list(await self.random_corpus_sample(1))[0]
-
-    async def random_corpus_sample(self, max_elements=100):
-        result = []
-        max_from_data = len(self.__corpus_data)
-
-        async def run():
-            nonlocal max_from_data
-            while len(result) < max_elements and (
-                max_from_data > 0 or self.__corpus_files
-            ):
-                i = self.__random.randrange(0, len(self.__corpus_files) + max_from_data)
-                if i < len(self.__corpus_files):
-                    j = len(self.__corpus_files) - 1
-                    self.__corpus_files[i], self.__corpus_files[j] = (
-                        self.__corpus_files[j],
-                        self.__corpus_files[i],
-                    )
-                    f = self.__corpus_files.pop()
-                    with open(f, "rb") as input:
-                        data = input.read()
-
-                    if await self.is_interesting(data):
-                        self.__corpus_data.append(data)
-                        result.append(data)
-                else:
-                    i -= len(self.__corpus_files)
-                    j = max_from_data - 1
-                    self.__corpus_data[i], self.__corpus_data[j] = (
-                        self.__corpus_data[j],
-                        self.__corpus_data[i],
-                    )
-                    result.append(self.__corpus_data[j])
-                    max_from_data -= 1
-                    await trio.lowlevel.checkpoint()
-
-        if self.__parallelism > 1:
-            async with trio.open_nursery() as nursery:
-                for _ in range(self.__parallelism):
-                    nursery.start_soon(run)
-        else:
-            await run()
-        return result[:max_elements]
-
-    async def random_reduction_problem(self):
-        while True:
-            sample = await self.random_corpus_sample(400)
-
-            index = defaultdict(list)
-
-            for i, s in enumerate(sample):
-                for j, c in enumerate(whitespace_normalize(s)):
-                    index[c].append((i, j))
-
-            queue = dequeue()
-
-            strings = [b""]
-
-            if not normalized:
-                continue
-            while True:
-                start = self.__random.randrange(0, len(normalized))
-                if not WHITESPACE.match(normalized[start : start + 1]):
-                    break
-            while True:
-                end = self.__random.randint(start, min(start + 20, len(normalized) - 1))
-                if not WHITESPACE.match(normalized[end : end + 1]):
-                    break
-            substring = normalized[start:end]
-            while True:
-                seed = str(self.__random.randint(0, 10**6)).encode("ascii")
-                value = threshold_value(seed=seed, test_case=initial)
-                if value >= 0.5:
-                    threshold = self.__random.random() * (1.0 - value) + value
-                    break
-
-            return initial, RandomInterestingnessTest(
-                seed=seed,
-                threshold=threshold,
-                key_substring=substring,
-                base_interestingness=self.is_interesting,
-            )
-
-    async def full_shrink(self, initial, condition) -> bytes:
-        problem: BasicReductionProblem[bytes] = BasicReductionProblem(
-            initial=initial,
-            is_interesting=condition,
-            work=WorkContext(parallelism=self.__parallelism, random=self.__random),
-        )
-
-        reducer = ShrinkRay(
-            target=problem,
-        )
-
-        await reducer.run()
-
-        return problem.current_test_case
-
-    async def all_shrinks(self, sample, condition):
-        shrinks = set()
-
-        async def run_and_add(c, condition):
-            shrinks.add(await self.full_shrink(c, condition))
-
-        async with trio.open_nursery() as nursery:
-            for d in sample:
-                nursery.start_soon(run_and_add, d, condition)
-
-        return shrinks
-
-
-def python_files() -> list[str]:
-    return [
-        f
-        for d in site.getsitepackages()
-        for f in glob(os.path.join(d, "**", "*.py"), recursive=True)
-    ]
-
-
-ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
-
-IS_PYTHON_SCRIPT = os.path.join(ROOT, "scripts", "ispython.py")
-
-assert os.path.exists(IS_PYTHON_SCRIPT), ROOT
-
-
-async def is_python(data):
-    return (
-        await trio.run_process(
-            [sys.executable, IS_PYTHON_SCRIPT],
-            stdin=data,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            check=False,
-        )
-    ).returncode == 0

shrinkray-0.0.0.dist-info/RECORD

@@ -1,22 +0,0 @@
-shrinkray/__init__.py,sha256=b5MvcvhsEGYya3GRXNbCJAlAL5IZHSsETLK_vtfmXRY,18
-shrinkray/__main__.py,sha256=DZDim25VQpQbKWNlK6EHS8Skz_IiK_Ykzutq0LldbXk,39128
-shrinkray/learning.py,sha256=K1FIkWRoue_auW4DmOrAOpiXumTfLRsBhH12a08lInA,7133
-shrinkray/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shrinkray/passes/bytes.py,sha256=9W-EoLt2Ateis3GMydkdVTSzx81YdEIt3f8FdTg-yXI,15846
-shrinkray/passes/clangdelta.py,sha256=lwhsrf9S75ULZ6OhIg_xlERFz7igLGjN9e9oDtzMFXw,7440
-shrinkray/passes/definitions.py,sha256=5EbxLg2LOgLrTiMUrlhMIC8hW6TyDhi5tcVBT0MA2hc,1208
-shrinkray/passes/genericlanguages.py,sha256=xxnPvV_ibW6e3SFIzgu5qxCujpQ7L_Drg1Bttvhj5xk,8214
-shrinkray/passes/json.py,sha256=iw-BdMCoOgebyZtlKibbj8CGE75RmlQZLghsG_VQXQ4,2348
-shrinkray/passes/patching.py,sha256=wfbYLajcav26w1HFXzyisEBOSfSTD8KC2qZ_EYLCN8E,8618
-shrinkray/passes/python.py,sha256=3ku9lzecA5UupzfHZOydDAV5Hqg83z9NTd6SfU-fQ3g,4933
-shrinkray/passes/sat.py,sha256=T70lcvNY1qJdiV1zlGRARUyqNb9lAE19LsrQa4i9wM0,5192
-shrinkray/passes/sequences.py,sha256=Q8Ldj23FjsLsfLzJS3_CU7hrU6jNuyG9BpvlBHO9lmU,2291
-shrinkray/problem.py,sha256=_LRPy9GRZ2nHohAQWkH6lOaVjV0h7SlrY_KTwjfKL68,10208
-shrinkray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shrinkray/reducer.py,sha256=Wm3e1g8HjJZ_qnkMYv9SnLbicBnmBr2O1vkBi6lgpmc,14274
-shrinkray/work.py,sha256=1Cmen3juWUIt5CFnUBhgR3qpIdYOnm8ykLv7EdJkgyQ,6707
-shrinkray-0.0.0.dist-info/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
-shrinkray-0.0.0.dist-info/METADATA,sha256=qAQK5h4szOvKtj1saZPW5wFb70uEY9Y9zoJbbtpYQg8,8994
-shrinkray-0.0.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-shrinkray-0.0.0.dist-info/entry_points.txt,sha256=u5D_5iY3G1LeHVljUDlmmHmQamz-Me5vLccZ9P7Lwm4,53
-shrinkray-0.0.0.dist-info/RECORD,,

shrinkray-0.0.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-shrinkray=shrinkray.__main__:main
-