shrinkray 25.12.27.1__tar.gz → 25.12.27.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.27.1
+Version: 25.12.27.3
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
@@ -159,30 +159,3 @@ not to handle well, but it's easy to extend with additional transformations.
 It is also fairly easy to add support for new formats as needed.
 
 If you run into a test case and interestingness test that you care about that shrink ray handles badly please let me know and I'll likely see about improving its handling of that format.
-
-## Parallelism
-
-You can control the number of parallel tasks shrinkray will run with the `--parallelism` flag. By default this will be the number of CPU cores you have available
-
-Shrink Ray is designed to be able to run heavily in parallel, with a basic heuristic of aiming to be embarrassingly parallel when making no progress, mostly sequential when making progress, and smoothly scaling in between the two. It mostly succeeds at this.
-
-Currently the bottleneck on scaling to a very large number of cores is how fast the controlling Python program can generate variant test cases to try and pass them to the interestingness test. This isn't well optimised at present and I don't currently have good benchmarks for it, but I'd expect you to be able to get linear speedups on most workflows while running 10-20 test cases in parallel, and to start to struggle past that.
-
-This also depends on the performance of the interestingness test - the slower your test is to run, the more you'll be able to scale linearly with the number of cores available.
-
-I'm quite interested in getting this part to scale well, so please let me know if you find examples where it doesn't seem to work.
-
-## Bug Reports
-
-Shrink Ray is still pretty new and under-tested software, so it definitely has bugs. If you run into any, [please file an issue](https://github.com/DRMacIver/shrinkray/issues).
-
-As well as obvious bugs (crashes, etc) I'm also very interested in hearing about usability issues and cases where the reduced test case isn't very good.
-
-Requests for new features, new supported formats, etc. also welcome although I'm less likely to jump right on them.
-
-## Sponsorship
-
-Shrink Ray is something of a labour of love - I wanted to have a tool that actually put into practice many of my ideas about test-case reduction, as I think the previous state of the art was well behind where I'd like it to be.
-
-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.27.1 → shrinkray-25.12.27.3}/README.md

@@ -119,30 +119,3 @@ not to handle well, but it's easy to extend with additional transformations.
 It is also fairly easy to add support for new formats as needed.
 
 If you run into a test case and interestingness test that you care about that shrink ray handles badly please let me know and I'll likely see about improving its handling of that format.
-
-## Parallelism
-
-You can control the number of parallel tasks shrinkray will run with the `--parallelism` flag. By default this will be the number of CPU cores you have available
-
-Shrink Ray is designed to be able to run heavily in parallel, with a basic heuristic of aiming to be embarrassingly parallel when making no progress, mostly sequential when making progress, and smoothly scaling in between the two. It mostly succeeds at this.
-
-Currently the bottleneck on scaling to a very large number of cores is how fast the controlling Python program can generate variant test cases to try and pass them to the interestingness test. This isn't well optimised at present and I don't currently have good benchmarks for it, but I'd expect you to be able to get linear speedups on most workflows while running 10-20 test cases in parallel, and to start to struggle past that.
-
-This also depends on the performance of the interestingness test - the slower your test is to run, the more you'll be able to scale linearly with the number of cores available.
-
-I'm quite interested in getting this part to scale well, so please let me know if you find examples where it doesn't seem to work.
-
-## Bug Reports
-
-Shrink Ray is still pretty new and under-tested software, so it definitely has bugs. If you run into any, [please file an issue](https://github.com/DRMacIver/shrinkray/issues).
-
-As well as obvious bugs (crashes, etc) I'm also very interested in hearing about usability issues and cases where the reduced test case isn't very good.
-
-Requests for new features, new supported formats, etc. also welcome although I'm less likely to jump right on them.
-
-## Sponsorship
-
-Shrink Ray is something of a labour of love - I wanted to have a tool that actually put into practice many of my ideas about test-case reduction, as I think the previous state of the art was well behind where I'd like it to be.
-
-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.27.1 → shrinkray-25.12.27.3}/pyproject.toml

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

{shrinkray-25.12.27.1 → shrinkray-25.12.27.3}/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.1 → shrinkray-25.12.27.3}/src/shrinkray/passes/bytes.py

@@ -24,8 +24,8 @@ from collections.abc import Sequence
 
 from attrs import define
 
-from shrinkray.passes.definitions import Format, ReductionProblem
 from shrinkray.passes.patching import Cuts, Patches, apply_patches
+from shrinkray.problem import Format, ReductionProblem
 
 
 @define(frozen=True)
@@ -739,12 +739,13 @@ async def line_sorter(problem: ReductionProblem[bytes]):
     while i < len(lines):
         j = i
         while j > 0:
-            u = lines[j - 1]
-            v = lines[j]
-            if v + u < u + v:
-                attempt = list(lines)
-                attempt[j - 1], attempt[j] = attempt[j], attempt[j - 1]
-                if not await problem.is_interesting(b"\n".join(attempt)):
+            attempt = list(lines)
+            attempt[j - 1], attempt[j] = attempt[j], attempt[j - 1]
+            new_test_case = b"\n".join(attempt)
+            if problem.sort_key(new_test_case) < problem.sort_key(
+                problem.current_test_case
+            ):
+                if not await problem.is_interesting(new_test_case):
                     break
                 else:
                     j -= 1

{shrinkray-25.12.27.1 → shrinkray-25.12.27.3}/src/shrinkray/passes/definitions.py

@@ -4,20 +4,20 @@ This module defines the core type aliases and abstractions for reduction:
 
 - ReductionPass[T]: A function that attempts to reduce a test case
 - ReductionPump[T]: A function that may temporarily increase test case size
-- Format[S, T]: A bidirectional transformation between types
 - compose(): Combines a Format with a pass to work on a different type
 
 These abstractions enable format-agnostic reduction: the same pass
 (e.g., "delete duplicate elements") can work on bytes, lines, tokens,
 JSON arrays, or any other sequence-like type.
+
+Note: Format, ParseError, and DumpError are defined in shrinkray.problem.
 """
 
-from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from functools import wraps
 from typing import TypeVar
 
-from shrinkray.problem import ReductionProblem
+from shrinkray.problem import Format, ParseError, ReductionProblem
 
 
 S = TypeVar("S")
@@ -36,70 +36,6 @@ ReductionPass = Callable[[ReductionProblem[T]], Awaitable[None]]
 ReductionPump = Callable[[ReductionProblem[T]], Awaitable[T]]
 
 
-class ParseError(Exception):
-    """Raised when a Format cannot parse its input."""
-
-    pass
-
-
-class DumpError(Exception):
-    """Raised when a Format cannot serialize its output.
-
-    This occurs because not all internal representations map to valid
-    output in the target format. For example, a reduction might create
-    an invalid AST structure that cannot be converted back to source code.
-    """
-
-    pass
-
-
-class Format[S, T](ABC):
-    """A bidirectional transformation between two types.
-
-    Formats enable format-agnostic passes by abstracting the
-    parse/serialize cycle. For example:
-
-    - Split(b"\\n"): bytes <-> list[bytes] (lines)
-    - Tokenize(): bytes <-> list[bytes] (tokens)
-    - JSON: bytes <-> Any (Python objects)
-    - DimacsCNF: bytes <-> list[list[int]] (SAT clauses)
-
-    A Format must satisfy the round-trip property:
-        dumps(parse(x)) should be equivalent to x
-        (possibly with normalization)
-
-    Example usage:
-        # Delete duplicate lines
-        compose(Split(b"\\n"), delete_duplicates)
-
-        # Reduce integer literals in source code
-        compose(IntegerFormat(), reduce_integer)
-    """
-
-    @property
-    def name(self) -> str:
-        """Human-readable name for this format, used in pass names."""
-        return repr(self)
-
-    @abstractmethod
-    def parse(self, input: S) -> T:
-        """Parse input into the target type. Raises ParseError on failure."""
-        ...
-
-    def is_valid(self, input: S) -> bool:
-        """Check if input can be parsed by this format."""
-        try:
-            self.parse(input)
-            return True
-        except ParseError:
-            return False
-
-    @abstractmethod
-    def dumps(self, input: T) -> S:
-        """Serialize the target type back to the source type."""
-        ...
-
-
 def compose(format: Format[S, T], reduction_pass: ReductionPass[T]) -> ReductionPass[S]:
     """Wrap a reduction pass to work through a Format transformation.
 

{shrinkray-25.12.27.1 → shrinkray-25.12.27.3}/src/shrinkray/passes/genericlanguages.py

@@ -3,7 +3,7 @@ Module of reduction passes designed for "things that look like programming langu
 """
 
 import re
-from collections.abc import Callable, Sized
+from collections.abc import Callable
 from functools import wraps
 from string import ascii_lowercase, ascii_uppercase
 from typing import AnyStr
@@ -12,9 +12,15 @@ import trio
 from attr import define
 
 from shrinkray.passes.bytes import ByteReplacement, delete_intervals
-from shrinkray.passes.definitions import Format, ParseError, ReductionPass
+from shrinkray.passes.definitions import ReductionPass
 from shrinkray.passes.patching import PatchApplier, Patches, apply_patches
-from shrinkray.problem import BasicReductionProblem, ReductionProblem
+from shrinkray.problem import (
+    BasicReductionProblem,
+    Format,
+    ParseError,
+    ReductionProblem,
+    sort_key_for_initial,
+)
 from shrinkray.work import NotFound
 
 
@@ -240,10 +246,6 @@ async def simplify_brackets(problem: ReductionProblem[bytes]) -> None:
 IDENTIFIER = re.compile(rb"(\b[A-Za-z][A-Za-z0-9_]*\b)|([0-9]+)")
 
 
-def shortlex[T: Sized](s: T) -> tuple[int, T]:
-    return (len(s), s)
-
-
 async def normalize_identifiers(problem: ReductionProblem[bytes]) -> None:
     """Replace identifiers with shorter alternatives.
 
@@ -261,8 +263,10 @@ async def normalize_identifiers(problem: ReductionProblem[bytes]) -> None:
                 replacements.add(c)
                 break
 
-    replacements = sorted(replacements, key=shortlex)
-    targets = sorted(identifiers, key=shortlex, reverse=True)
+    sort_key = sort_key_for_initial(problem.current_test_case)
+
+    replacements = sorted(replacements, key=sort_key)
+    targets = sorted(identifiers, key=sort_key, reverse=True)
 
     # TODO: This could use better parallelisation.
     for t in targets:
@@ -272,7 +276,7 @@ async def normalize_identifiers(problem: ReductionProblem[bytes]) -> None:
             continue
 
         async def can_replace(r):
-            if shortlex(r) >= shortlex(t):
+            if sort_key(r) >= sort_key(t):
                 return False
             attempt = pattern.sub(r, source)
             assert attempt != source

{shrinkray-25.12.27.1 → shrinkray-25.12.27.3}/src/shrinkray/passes/json.py

@@ -4,9 +4,9 @@ from typing import Any
 
 from attrs import define
 
-from shrinkray.passes.definitions import Format, ParseError, ReductionPass
+from shrinkray.passes.definitions import ReductionPass
 from shrinkray.passes.patching import Patches, apply_patches
-from shrinkray.problem import ReductionProblem
+from shrinkray.problem import Format, ParseError, ReductionProblem
 
 
 def is_json(s: bytes) -> bool:

{shrinkray-25.12.27.1 → shrinkray-25.12.27.3}/src/shrinkray/passes/sat.py

@@ -1,15 +1,10 @@
 from collections import Counter, defaultdict
 from collections.abc import Callable, Iterable, Iterator
 
-from shrinkray.passes.definitions import (
-    DumpError,
-    Format,
-    ParseError,
-    ReductionPass,
-)
+from shrinkray.passes.definitions import ReductionPass
 from shrinkray.passes.patching import Conflict, SetPatches, apply_patches
 from shrinkray.passes.sequences import delete_elements
-from shrinkray.problem import ReductionProblem
+from shrinkray.problem import DumpError, Format, ParseError, ReductionProblem
 
 
 Clause = list[int]