ci: fix formatting and linting issues

- Run black formatter on all source and test files
- Fix ruff violations (imports, typing, whitespace)
- Update ruff config to use lint.* sections
- Add fail-fast: false to CI matrix for better diagnostics
- Add tool version printing step for Python 3.12 job

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: RobLe3

.github/workflows/ci.yml

@@ -10,6 +10,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12"]
 
@@ -26,6 +27,15 @@ jobs:
         python -m pip install --upgrade pip
         pip install -e ".[dev]"
 
+    - name: Print tool versions
+      run: |
+        python --version
+        pip --version
+        black --version
+        ruff --version
+        pytest --version
+      if: matrix.python-version == '3.12'
+
     - name: Run tests
       run: |
         pytest -v

pyproject.toml

@@ -71,6 +71,8 @@ include = '\.pyi?$'
 [tool.ruff]
 line-length = 100
 target-version = "py310"
+
+[tool.ruff.lint]
 select = [
     "E",  # pycodestyle errors
     "W",  # pycodestyle warnings

src/lulzprime/__init__.py

@@ -23,11 +23,11 @@
 __version__ = "0.1.0"
 
 # Public API exports
-from .resolve import resolve, between, next_prime, prev_prime
+from .batch import between_many, resolve_many
 from .forecast import forecast
 from .primality import is_prime
+from .resolve import between, next_prime, prev_prime, resolve
 from .simulator import simulate
-from .batch import resolve_many, between_many
 
 __all__ = [
     "resolve",

src/lulzprime/batch.py

@@ -9,11 +9,12 @@
 Canonical reference: https://roblemumin.com/library.html
 """
 
-from typing import Iterable
-from .utils import validate_index, validate_range
+from collections.abc import Iterable
+
 from .lookup import resolve_internal_with_pi
-from .resolve import between as _between
 from .pi import pi as default_pi
+from .resolve import between as _between
+from .utils import validate_index
 
 
 def resolve_many(indices: Iterable[int]) -> list[int]:
@@ -162,9 +163,13 @@ def between_many(ranges: Iterable[tuple[int, int]]) -> list[list[int]]:
     for i, range_tuple in enumerate(ranges_list):
         # Validate tuple structure
         if not isinstance(range_tuple, tuple):
-            raise TypeError(f"Range at position {i} must be a tuple, got {type(range_tuple).__name__}")
+            raise TypeError(
+                f"Range at position {i} must be a tuple, got {type(range_tuple).__name__}"
+            )
         if len(range_tuple) != 2:
-            raise ValueError(f"Range at position {i} must be a 2-tuple (x, y), got length {len(range_tuple)}")
+            raise ValueError(
+                f"Range at position {i} must be a 2-tuple (x, y), got length {len(range_tuple)}"
+            )
 
         x, y = range_tuple
 
@@ -176,5 +181,3 @@ def between_many(ranges: Iterable[tuple[int, int]]) -> list[list[int]]:
             raise type(e)(f"Invalid range at position {i}: {e}") from None
 
     return results
-
-

src/lulzprime/config.py

@@ -11,8 +11,31 @@
 # Small primes cache for optimization
 # These are used for quick lookups and divisibility checks
 SMALL_PRIMES = [
-    2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
-    53, 59, 61, 67, 71, 73, 79, 83, 89, 97
+    2,
+    3,
+    5,
+    7,
+    11,
+    13,
+    17,
+    19,
+    23,
+    29,
+    31,
+    37,
+    41,
+    43,
+    47,
+    53,
+    59,
+    61,
+    67,
+    71,
+    73,
+    79,
+    83,
+    89,
+    97,
 ]
 
 # Forecast thresholds

src/lulzprime/diagnostics.py

@@ -9,8 +9,9 @@
 IMPORTANT: Diagnostics must observe only. They must never alter computational results.
 """
 
-from typing import Any, Callable
-from dataclasses import dataclass, field
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
 
 
 def verify_resolution(result: int, index: int, pi_func: Callable, is_prime_func: Callable) -> bool:
@@ -35,9 +36,7 @@ def verify_resolution(result: int, index: int, pi_func: Callable, is_prime_func:
     """
     # Check primality
     if not is_prime_func(result):
-        raise AssertionError(
-            f"Resolution verification failed: result {result} is not prime"
-        )
+        raise AssertionError(f"Resolution verification failed: result {result} is not prime")
 
     # Check index
     pi_result = pi_func(result)
@@ -78,15 +77,15 @@ def verify_range(primes: list[int], is_prime_func: Callable) -> bool:
 
     # Check strictly increasing
     for i in range(1, len(primes)):
-        if primes[i] <= primes[i-1]:
-            raise AssertionError(
-                f"Range verification failed: not strictly increasing at index {i}"
-            )
+        if primes[i] <= primes[i - 1]:
+            raise AssertionError(f"Range verification failed: not strictly increasing at index {i}")
 
     return True
 
 
-def check_forecast_quality(index: int, forecast_value: int, pi_func: Callable, epsilon: float = 0.1) -> dict[str, Any]:
+def check_forecast_quality(
+    index: int, forecast_value: int, pi_func: Callable, epsilon: float = 0.1
+) -> dict[str, Any]:
     """
     Check forecast quality (Tier C sanity check).
 
@@ -109,10 +108,10 @@ def check_forecast_quality(index: int, forecast_value: int, pi_func: Callable, e
     relative_error = abs(pi_forecast - index) / index
 
     return {
-        'passed': relative_error < epsilon,
-        'relative_error': relative_error,
-        'pi_forecast': pi_forecast,
-        'threshold': epsilon,
+        "passed": relative_error < epsilon,
+        "relative_error": relative_error,
+        "pi_forecast": pi_forecast,
+        "threshold": epsilon,
     }
 
 
@@ -132,10 +131,9 @@ def simulator_diagnostics(sequence: list[int], pi_func: Callable) -> dict[str, A
     Returns:
         Dictionary with diagnostic metrics
     """
-    import math
 
     if not sequence:
-        return {'error': 'empty sequence'}
+        return {"error": "empty sequence"}
 
     n = len(sequence)
     q_final = sequence[-1]
@@ -151,24 +149,26 @@ def simulator_diagnostics(sequence: list[int], pi_func: Callable) -> dict[str, A
             q_i = sequence[i]
             pi_i = pi_func(q_i)
             ratio_i = pi_i / (i + 1)
-            checkpoints.append({
-                'step': i + 1,
-                'q': q_i,
-                'pi': pi_i,
-                'density_ratio': ratio_i,
-            })
+            checkpoints.append(
+                {
+                    "step": i + 1,
+                    "q": q_i,
+                    "pi": pi_i,
+                    "density_ratio": ratio_i,
+                }
+            )
 
     # Compute drift (deviation from expected ratio of 1.0)
     drift = abs(density_ratio - 1.0)
 
     return {
-        'n_steps': n,
-        'q_final': q_final,
-        'pi_final': pi_final,
-        'density_ratio': density_ratio,
-        'drift': drift,
-        'convergence_acceptable': drift < 0.15,  # Threshold from paper
-        'checkpoints': checkpoints,
+        "n_steps": n,
+        "q_final": q_final,
+        "pi_final": pi_final,
+        "density_ratio": density_ratio,
+        "drift": drift,
+        "convergence_acceptable": drift < 0.15,  # Threshold from paper
+        "checkpoints": checkpoints,
     }
 
 
@@ -188,6 +188,7 @@ class ResolveStats:
         forecast_value: Initial forecast estimate
         final_result: Final resolved prime value
     """
+
     pi_calls: int = 0
     binary_search_iterations: int = 0
     correction_backward_steps: int = 0
@@ -222,14 +223,15 @@ def set_result(self, value: int) -> None:
     def to_dict(self) -> dict[str, Any]:
         """Convert stats to dictionary for reporting."""
         return {
-            'pi_calls': self.pi_calls,
-            'binary_search_iterations': self.binary_search_iterations,
-            'correction_backward_steps': self.correction_backward_steps,
-            'correction_forward_steps': self.correction_forward_steps,
-            'forecast_value': self.forecast_value,
-            'final_result': self.final_result,
+            "pi_calls": self.pi_calls,
+            "binary_search_iterations": self.binary_search_iterations,
+            "correction_backward_steps": self.correction_backward_steps,
+            "correction_forward_steps": self.correction_forward_steps,
+            "forecast_value": self.forecast_value,
+            "final_result": self.final_result,
         }
 
+
 @dataclass
 class MeisselStats:
     """
@@ -245,6 +247,7 @@ class MeisselStats:
         recursion_depth_max: Maximum recursion depth reached
         recursion_guard_trips: Number of times recursion guard triggered
     """
+
     phi_calls: int = 0
     phi_cache_size: int = 0
     pi_cache_size: int = 0
@@ -274,9 +277,9 @@ def increment_recursion_guard_trips(self) -> None:
     def to_dict(self) -> dict[str, Any]:
         """Convert stats to dictionary for reporting."""
         return {
-            'phi_calls': self.phi_calls,
-            'phi_cache_size': self.phi_cache_size,
-            'pi_cache_size': self.pi_cache_size,
-            'recursion_depth_max': self.recursion_depth_max,
-            'recursion_guard_trips': self.recursion_guard_trips,
+            "phi_calls": self.phi_calls,
+            "phi_cache_size": self.phi_cache_size,
+            "pi_cache_size": self.pi_cache_size,
+            "recursion_depth_max": self.recursion_depth_max,
+            "recursion_guard_trips": self.recursion_guard_trips,
         }

src/lulzprime/forecast.py

@@ -8,8 +8,8 @@
 Output class: Tier C (Estimate only)
 """
 
-from .config import SMALL_PRIMES, FORECAST_SMALL_THRESHOLD
-from .utils import log_n, log_log_n, validate_index
+from .config import FORECAST_SMALL_THRESHOLD, SMALL_PRIMES
+from .utils import log_log_n, log_n, validate_index
 
 
 def forecast(index: int) -> int:

src/lulzprime/gaps.py

@@ -7,8 +7,6 @@
 Canonical reference: https://roblemumin.com/library.html
 """
 
-from typing import Optional
-
 
 def get_empirical_gap_distribution(
     max_gap: int = 100,
@@ -96,7 +94,7 @@ def tilt_gap_distribution(
 
 def sample_gap(
     distribution: dict[int, float],
-    rng: Optional[object] = None,
+    rng: object | None = None,
 ) -> int:
     """
     Sample a gap from the given distribution.

src/lulzprime/lehmer.py

@@ -46,7 +46,6 @@
 """
 
 import math
-from functools import lru_cache
 
 
 def _simple_sieve(limit: int) -> list[int]:
@@ -217,11 +216,11 @@ def _integer_cube_root(x: int) -> int:
         return 1
 
     # Initial guess using floating-point (will be refined)
-    k = int(x ** (1/3))
+    k = int(x ** (1 / 3))
 
     # Refine using Newton's method with integer arithmetic
     # Ensures we find the exact integer cube root
-    while k ** 3 > x:
+    while k**3 > x:
         k -= 1
     while (k + 1) ** 3 <= x:
         k += 1

src/lulzprime/lookup.py

@@ -7,11 +7,12 @@
 Canonical reference: https://roblemumin.com/library.html
 """
 
-from typing import Callable, Optional
+from collections.abc import Callable
+
+from .diagnostics import ResolveStats
 from .forecast import forecast
 from .pi import pi
-from .primality import is_prime, prev_prime, next_prime
-from .diagnostics import ResolveStats
+from .primality import is_prime, next_prime, prev_prime
 
 
 def resolve_internal(index: int) -> int:
@@ -37,9 +38,7 @@ def resolve_internal(index: int) -> int:
 
 
 def resolve_internal_with_pi(
-    index: int,
-    pi_fn: Callable[[int], int],
-    stats: Optional[ResolveStats] = None
+    index: int, pi_fn: Callable[[int], int], stats: ResolveStats | None = None
 ) -> int:
     """
     Internal resolution pipeline with injected π(x) function.
@@ -67,9 +66,11 @@ def resolve_internal_with_pi(
 
     # Wrap pi_fn to count calls if stats is enabled
     if stats:
+
         def counted_pi_fn(x: int) -> int:
             stats.increment_pi_calls()
             return pi_fn(x)
+
     else:
         counted_pi_fn = pi_fn
 
@@ -113,7 +114,7 @@ def _binary_search_pi(
     target_index: int,
     guess: int,
     pi_fn: Callable[[int], int] = pi,
-    stats: Optional[ResolveStats] = None
+    stats: ResolveStats | None = None,
 ) -> int:
     """
     Binary search to find minimal x where π(x) >= target_index.
@@ -132,7 +133,7 @@ def _binary_search_pi(
     # to reduce binary search iterations. This cuts search space by ~2x.
     # Conservative bounds: 5% margin on each side (safer than analytic formula)
     lo = max(2, int(guess * 0.95))  # 5% below forecast
-    hi = int(guess * 1.05)           # 5% above forecast
+    hi = int(guess * 1.05)  # 5% above forecast
 
     # Adjust if initial bounds are wrong
     if pi_fn(lo) > target_index: