Merge pull request #43 from SaridakisStamatisChristos/codex/move-hypothesis-stub-and-add-tests

Conditionally use Hypothesis stub and expand regression tests

Author: SaridakisStamatisChristos

hypothesis/__init__.py

@@ -0,0 +1,49 @@
+"""Minimal Hypothesis stub used only when the real package is unavailable."""
+from __future__ import annotations
+from enum import Enum
+from functools import wraps
+import inspect
+from itertools import product
+from typing import Any, Callable, Dict, List, Sequence, Tuple
+from . import strategies as strategies
+__all__ = ["HealthCheck","Phase","given","settings","strategies"]
+class HealthCheck(str, Enum):
+    too_slow = "too_slow"
+    filter_too_much = "filter_too_much"
+    data_too_large = "data_too_large"
+class Phase(str, Enum):
+    generate = "generate"
+    shrink = "shrink"
+class settings:
+    _profiles: Dict[str, Dict[str, Any]] = {"default": {}}
+    _active_profile: Dict[str, Any] = _profiles["default"].copy()
+    def __init__(self, **kwargs: Any) -> None:
+        self.kwargs = kwargs
+    def __call__(self, func: Callable[..., Any]) -> Callable[..., Any]:
+        func._hypothesis_settings = self.kwargs  # type: ignore[attr-defined]
+        return func
+    @classmethod
+    def register_profile(cls, name: str, **kwargs: Any) -> None:
+        cls._profiles[name] = dict(kwargs)
+    @classmethod
+    def load_profile(cls, name: str) -> None:
+        cls._active_profile = cls._profiles.get(name, cls._profiles["default"]).copy()
+    @classmethod
+    def get_active_profile(cls) -> Dict[str, Any]:
+        return cls._active_profile
+
+def given(*strategies_args: strategies.Strategy, **strategies_kwargs: strategies.Strategy):
+    if strategies_kwargs:
+        raise NotImplementedError("keyword strategies are not supported in this stub")
+    example_lists: List[Sequence[Any]] = [s.examples() for s in strategies_args]
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        if not example_lists:
+            return func
+        example_product: List[Tuple[Any, ...]] = list(product(*example_lists))
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            for example in example_product:
+                func(*example)
+        wrapper.__signature__ = inspect.Signature()  # type: ignore[attr-defined]
+        return wrapper
+    return decorator

tests/_stubs/hypothesis/__init__.py

@@ -1,30 +1,18 @@
-"""Deterministic stand-ins for the handful of Hypothesis strategies we need."""
-
+"""Deterministic stand-ins for a tiny subset of Hypothesis strategies."""
 from __future__ import annotations
-
 from dataclasses import dataclass
 from typing import Iterable, List, Sequence
-
 __all__ = ["Strategy", "sampled_from", "lists", "text"]
-
-
 class Strategy:
-    """Base strategy API matching the expectations of :func:`hypothesis.given`."""
-
-    def examples(self) -> Sequence[object]:  # pragma: no cover - interface only
+    def examples(self) -> Sequence[object]:
         raise NotImplementedError
-
-
 @dataclass
 class SampledFromStrategy(Strategy):
     values: Sequence[object]
-
     def __post_init__(self) -> None:
         if not self.values:
             self.values = [None]
-
     def examples(self) -> Sequence[object]:
-        # Provide a handful of distinct representatives while preserving order.
         unique: List[object] = []
         for candidate in (self.values[0], self.values[-1]):
             if candidate not in unique:
@@ -33,27 +21,16 @@ def examples(self) -> Sequence[object]:
         if midpoint not in unique:
             unique.append(midpoint)
         return tuple(unique)
-
     def cycle(self, length: int, *, reverse: bool = False, offset: int = 0) -> List[object]:
-        items = list(self.values[::-1] if reverse else self.values)
-        if not items:
-            items = [None]
-        out: List[object] = []
-        for i in range(length):
-            out.append(items[(i + offset) % len(items)])
-        return out
-
-
+        items = list(self.values[::-1] if reverse else self.values) or [None]
+        return [items[(i + offset) % len(items)] for i in range(length)]
 @dataclass
 class ListStrategy(Strategy):
     inner: Strategy
     min_size: int
     max_size: int
-
     def examples(self) -> Sequence[object]:
-        length = self.min_size
-        if self.max_size < self.min_size:
-            length = self.max_size
+        length = min(max(self.min_size, 0), max(self.max_size, 0))
         cycle = getattr(self.inner, "cycle", None)
         if callable(cycle):
             base = cycle(length)
@@ -64,13 +41,11 @@ def examples(self) -> Sequence[object]:
             base = [(base_values[i % len(base_values)]) for i in range(length)]
             rotated = base[::-1]
             reversed_cycle = base_values[:length]
-
         examples: List[List[object]] = [list(base)]
         if rotated and rotated != base:
             examples.append(list(rotated))
         if reversed_cycle and reversed_cycle not in examples:
             examples.append(list(reversed_cycle))
-
         if self.max_size > self.min_size:
             alt_length = self.max_size
             if callable(cycle):
@@ -80,39 +55,25 @@ def examples(self) -> Sequence[object]:
                 alt = [(base_values[i % len(base_values)]) for i in range(alt_length)]
             if alt:
                 examples.append(list(alt))
-
         return tuple(examples)
-
-
 @dataclass
 class TextStrategy(Strategy):
     alphabet: Strategy
     min_size: int
     max_size: int
-
     def examples(self) -> Sequence[object]:
-        chars = [str(c) for c in self.alphabet.examples() if str(c)]
-        if not chars:
-            chars = [""]
-
+        chars = [str(c) for c in self.alphabet.examples() if str(c)] or [""]
         examples: List[str] = [""]
         if self.min_size > 0:
-            repeat_count = max(self.min_size, 1)
-            repeat_count = min(repeat_count, self.max_size)
+            repeat_count = min(max(self.min_size, 1), self.max_size)
             examples.append(chars[0] * repeat_count)
         if len(chars) > 1:
             joined = "".join(chars)
             examples.append(joined[: self.max_size])
         return tuple(examples)
-
-
 def sampled_from(values: Iterable[object]) -> SampledFromStrategy:
     return SampledFromStrategy(tuple(values))
-
-
 def lists(inner: Strategy, *, min_size: int, max_size: int) -> ListStrategy:
     return ListStrategy(inner=inner, min_size=min_size, max_size=max_size)
-
-
 def text(*, alphabet: Strategy, min_size: int, max_size: int) -> TextStrategy:
     return TextStrategy(alphabet=alphabet, min_size=min_size, max_size=max_size)

hypothesis/strategies.py renamed to tests/_stubs/hypothesis/strategies.py

@@ -5,9 +5,15 @@
 import sys
 from pathlib import Path
 
+if os.getenv("USE_HYPOTHESIS_STUB") == "1" or importlib.util.find_spec("hypothesis") is None:
+    stub_path = Path(__file__).parent / "_stubs"
+    stub_str = str(stub_path)
+    if stub_str not in sys.path:
+        sys.path.insert(0, stub_str)
+
 from _pytest.config import Config
 from _pytest.config.argparsing import Parser
-from hypothesis import HealthCheck, Phase, settings
+from hypothesis import HealthCheck, Phase, settings  # type: ignore
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
 SRC_PATH = PROJECT_ROOT / "src"

tests/conftest.py

@@ -0,0 +1,37 @@
+from sudoku_dlx import from_string, to_string, canonical_form
+
+PUZ = (
+    "53..7...."
+    "6..195..."
+    ".98....6."
+    "8...6...3"
+    "4..8.3..1"
+    "7...2...6"
+    ".6....28."
+    "...419..5"
+    "....8..79"
+)
+
+def rot180(s: str) -> str:
+    return s[::-1]
+
+def swap_rows_in_band(grid, band, r1, r2):
+    g = [row[:] for row in grid]
+    base = band * 3
+    g[base + r1], g[base + r2] = g[base + r2], g[base + r1]
+    return g
+
+def test_canonical_invariant_under_basic_isomorphs():
+    g = from_string(PUZ)
+    c0 = canonical_form(g)
+    # rot180 string
+    c1 = canonical_form(from_string(rot180(PUZ)))
+    assert c1 == c0
+    # swap two rows within a band
+    g2 = swap_rows_in_band(g, band=0, r1=0, r2=2)
+    c2 = canonical_form(g2)
+    assert c2 == c0
+    # relabel digits 1<->9 on the string
+    trans = str.maketrans("123456789", "987654321")
+    c3 = canonical_form(from_string(to_string(g).translate(trans)))
+    assert c3 == c0

tests/test_canonical_invariance.py

@@ -0,0 +1,32 @@
+from sudoku_dlx.formats import read_grids, write_grids, detect_format
+
+PUZ = (
+    "53..7...."
+    "6..195..."
+    ".98....6."
+    "8...6...3"
+    "4..8.3..1"
+    "7...2...6"
+    ".6....28."
+    "...419..5"
+    "....8..79"
+)
+
+def test_txt_csv_jsonl_roundtrip(tmp_path):
+    ptxt = tmp_path / "a.txt"
+    ptxt.write_text(PUZ + "\n" + PUZ + "\n", encoding="utf-8")
+    grids = read_grids(str(ptxt), "txt")
+    assert grids and grids[0] == PUZ
+    pcsv = tmp_path / "b.csv"
+    write_grids(str(pcsv), grids, "csv")
+    grids2 = read_grids(str(pcsv), "csv")
+    assert grids2 == grids
+    pjsonl = tmp_path / "c.jsonl"
+    write_grids(str(pjsonl), grids2, "jsonl")
+    grids3 = read_grids(str(pjsonl), "jsonl")
+    assert grids3 == grids
+
+def test_detect_format_defaults_txt(tmp_path):
+    assert detect_format("x.sdk") == "txt"
+    assert detect_format("x.ndjson") == "jsonl"
+    assert detect_format("x.unknown") == "txt"