v0.6.5: ruff .venv exclude, decoder module fixes, test suite fixes

- pyproject.toml: exclude .venv/.venv_clean_test/target/dist/lib/proto from ruff scope, add per-file ignores for cpu_benchmark_report.py and test_exports.py
- belief_matching.py, bposd.py, decode_mmap.py, decoder_cache.py, decoder_pool.py, result.py, torch_predecoder.py: v0.6.5 fixes
- qector_decoder_v3.pyi: formatting (multi-line signatures collapsed), no API surface change
- test_comprehensive_suite.py: fix syndrome/syndromes NameError in _run_pool_test, format cleanup
- test_bulletproof.py, test_decoders.py, test_ecosystem.py, test_examples.py, test_lookup_table.py, test_max_capacity.py, test_new_modules.py: test fixes for v0.6.5 API
- README.md, PYPI_README.md: doc updates

Verified locally: ruff 0 errors, mypy 0 issues (25 files), cargo check clean,
pytest 988 passed / 101 skipped / 0 failed (32:41).

Author: qectorlab

PYPI_README.md

@@ -144,7 +144,7 @@ Important boundaries:
 - GPU availability and performance depend on wheel build features, drivers, hardware, and runtime checks.
 - OpenCL support must be confirmed on the target machine or built under the appropriate licensed/custom configuration.
 - REST/API surfaces are for local experiments or controlled review unless separately hardened.
-- **v0.6.5**: mypy-clean Python layer (zero type errors), test suite aligned with installed API, decoder name consistency (`union_find` canonical), all lint/type checks pass.
+- **v0.6.4**: CPU batch decoder now reaches 1.1M shots/s via AVX2 SIMD transpose. BP-OSD adds `decode_timed` with convergence cap. Blossom intra-decode Rayon parallelism. DecoderPool auto-Rayon on Windows.
 
 Full methodology, reproducibility notes, and benchmark artifacts are in the GitHub repository:
 
@@ -165,7 +165,7 @@ Do this before making any hardware-specific performance claim.
 
 ---
 
-## v0.6.5 Highlights
+## v0.6.4 Highlights
 
 | Feature | Description |
 | --- | --- |
@@ -204,7 +204,7 @@ Contact:
   author  = {Guillaume Lessard},
   title   = {{QECTOR Decoder v3}: Rust/Python Quantum Error Correction Decoding Platform},
   year    = {2026},
-  version = {0.6.5},
+  version = {0.6.4},
   url     = {https://www.qector.store},
   note    = {Source-available. Commercial license required for commercial use.}
 }

README.md

@@ -188,7 +188,7 @@ See the public API regression coverage in [python/tests](python/tests) before bu
 
 ---
 
-## New in v0.6.5
+## New in v0.6.4
 
 | Feature | Description |
 | --- | --- |
@@ -214,15 +214,15 @@ If you need the full desktop GUI, hosted automation stack, or additional documen
 
 ## Validated evidence snapshot
 
-All public claims should cite an artifact, commit, command, machine, and version. The current package release is **v0.6.5**; checked-in evidence should be regenerated before making new performance claims.
+All public claims should cite an artifact, commit, command, machine, and version. The current package release is **v0.6.4**; checked-in evidence should be regenerated before making new performance claims.
 
-> **v0.6.5 additions**: mypy-clean Python layer, test suite API fixes, decoder name consistency (`union_find` canonical).
+> **v0.6.4 additions**: AVX2 SIMD transpose (CPU batch 1.1M shots/s), BP-OSD convergence cap (`decode_timed`), Blossom intra-decode Rayon parallelism, DecoderPool auto-Rayon on Windows.
 
 ### MWPM parity against PyMatching
 
 Artifact: `benchmark_results/stim_ler_d13_d15.json`
 
-Environment: Windows 10/11 class x64 machine, Python 3.11+, QECTOR v0.6.5 + v3.3 Workbench, PyMatching 2.4+, Stim 1.16+, 20,000 shots per distance.
+Environment: Windows 10/11 class x64 machine, Python 3.11+, QECTOR v0.6.4 + v3.3 Workbench, PyMatching 2.4+, Stim 1.16+, 20,000 shots per distance.
 
 | Distance | QECTOR Blossom LER | PyMatching LER | QECTOR us/shot | PyMatching us/shot |
 | ---: | ---: | ---: | ---: | ---: |
@@ -428,7 +428,7 @@ See [LICENSE](LICENSE) for the repository terms and contact the commercial team
   author  = {Guillaume Lessard},
   title   = {{QECTOR Decoder v3}: Rust/Python Quantum Error Correction Decoding Platform},
   year    = {2026},
-  version = {0.6.5},
+  version = {0.6.4},
   url     = {https://www.qector.store},
   note    = {Source-available. Commercial license required for commercial use.}
 }

pyproject.toml

@@ -129,6 +129,7 @@ ignore_missing_imports = true
 [tool.ruff]
 line-length = 120
 target-version = "py39"
+extend-exclude = [".venv", ".venv_clean_test", "target", "dist", "lib", "proto"]
 
 [tool.ruff.format]
 # Ensure consistent formatting on Linux CI runners (LF) even when edited on Windows.
@@ -156,3 +157,9 @@ ignore = ["E702", "E731", "E741"]
 # f-strings used as comment-like strings for readability (F541).
 "python/tests/*.py" = ["E402", "F401", "F541", "F841"]
 "python/tests/**/*.py" = ["E402", "F401", "F541", "F841"]
+# matplotlib.use("Agg") must precede pyplot import to force a non-interactive
+# backend before any GUI backend can be auto-selected; this ordering is required.
+"cpu_benchmark_report.py" = ["E402"]
+# test_exports.py runs a manual integration script top-to-bottom; the smoke_test_wheel
+# import is intentionally placed after other exercises run, and imported for side effects.
+"test_exports.py" = ["E402"]

python/qector_decoder_v3/belief_matching.py

@@ -34,7 +34,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, FrozenSet, List
+from typing import Any, Dict, FrozenSet, List, Set, Tuple
 
 import numpy as np
 
@@ -208,17 +208,10 @@ def from_numpy_h(cls, H, error_rate: float = 0.05, max_iter: int = 20) -> "Belie
             raise ValueError(f"H must be 2D, got {H.shape}")
         nD, nQ = H.shape
 
-        hyper_ids: dict[tuple[int, ...], int] = {}
-        edge_ids: dict[tuple[int, ...], int] = {}
-        hyper_to_edges: dict[int, set[int]] = {}
-        priors: dict[int, float] = {}
-        # Type hints for mypy
-        _hyper_ids: dict[tuple[int, ...], int] = hyper_ids
-        _edge_ids: dict[tuple[int, ...], int] = edge_ids
-        _hyper_to_edges: dict[int, set[int]] = hyper_to_edges
-        _priors: dict[int, float] = priors
-        # Avoid unused variable warnings
-        _ = _hyper_ids, _edge_ids, _hyper_to_edges, _priors
+        hyper_ids: Dict[Tuple[int, ...], int] = {}
+        edge_ids: Dict[Tuple[int, ...], int] = {}
+        hyper_to_edges: Dict[int, Set[int]] = {}
+        priors: Dict[int, float] = {}
 
         for q in range(nQ):
             dets = tuple(sorted(np.nonzero(H[:, q])[0].tolist()))

python/qector_decoder_v3/bposd.py

@@ -82,7 +82,6 @@ def decode(self, syndrome) -> np.ndarray:
 
         if self.max_latency_ms is not None:
             import time as _time
-
             t_start = _time.perf_counter()
             max_seconds = self.max_latency_ms / 1000.0
 
@@ -111,7 +110,6 @@ def decode(self, syndrome) -> np.ndarray:
 
         if self.max_latency_ms is not None and (_time.perf_counter() - t_start) > max_seconds:
             from . import UnionFindDecoder
-
             checks = [sorted(int(c) for c in np.nonzero(self.H[r])[0]) for r in range(self.n_checks)]
             uf = UnionFindDecoder(checks, self.n_qubits)
             return np.asarray(uf.decode(s), dtype=np.uint8).reshape(-1)
@@ -228,7 +226,9 @@ def _osd(self, s: np.ndarray, posterior: np.ndarray) -> np.ndarray:
 # ---------------------------------------------------------------------------
 # GF(2) ordered-statistics solve
 # ---------------------------------------------------------------------------
-def _gf2_osd_solve(H: np.ndarray, s: np.ndarray, order: np.ndarray, hard: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+def _gf2_osd_solve(
+    H: np.ndarray, s: np.ndarray, order: np.ndarray, hard: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray]:
     """OSD-0 solve. ``order`` lists columns least-reliable first; the first
     rank(H) independent of them form the basis, the rest (free) take their BP hard
     decision, and the basis is solved so ``H x == s (mod 2)``.

python/qector_decoder_v3/decode_mmap.py

@@ -12,16 +12,18 @@
 >>> checks, nq = generate_repetition_code_checks(distance=5)
 >>> n_shots = 10000
 >>> # Create a memory-mapped syndrome file
->>> syn = np.memmap("syndromes.bin", dtype=np.uint8, mode="w+", shape=(n_shots, len(checks)))
+>>> syn = np.memmap("syndromes.bin", dtype=np.uint8, mode="w+",
+...                  shape=(n_shots, len(checks)))
 >>> syn[:] = (np.random.random((n_shots, len(checks))) < 0.1).astype(np.uint8)
 >>> syn.flush()
->>> decode_mmap("syndromes.bin", "corrections.bin", checks, nq, batch_size=1024, n_shots=n_shots)
+>>> decode_mmap("syndromes.bin", "corrections.bin",
+...             checks, nq, batch_size=1024, n_shots=n_shots)
 """
 
 from __future__ import annotations
 
 import os as _os
-from typing import Optional
+from typing import Optional, Union
 
 import numpy as _np
 
@@ -36,7 +38,7 @@ def decode_mmap(
     decoder_type: str = "cpu_batch",
     batch_size: int = 65536,
     n_shots: Optional[int] = None,
-    dtype: _np.dtype[_np.uint8] = _np.dtype(_np.uint8),
+    dtype: _np.dtype = _np.dtype(_np.uint8),
     verbose: bool = False,
 ):
     """Out-of-core batch decoding via memory-mapped arrays.
@@ -64,30 +66,21 @@ def decode_mmap(
         n_shots = file_size // bytes_per_shot
     if file_size < n_shots * bytes_per_shot:
         raise ValueError(
-            f"syndrome file too small: {file_size} bytes, need {n_shots * bytes_per_shot} for {n_shots} shots"
+            f"syndrome file too small: {file_size} bytes, "
+            f"need {n_shots * bytes_per_shot} for {n_shots} shots"
         )
 
     syndromes = _np.memmap(syndrome_path, dtype=dtype, mode="r", shape=(n_shots, n_checks))
     output = _np.memmap(output_path, dtype=_np.uint8, mode="w+", shape=(n_shots, n_qubits))
 
     from . import CPUBatchDecoder, UnionFindDecoder
-    from typing import Union
-
-    _Decoder = Union[CPUBatchDecoder, UnionFindDecoder]
-
+    decoder: Union[CPUBatchDecoder, UnionFindDecoder]
     if decoder_type == "cpu_batch":
-        decoder: _Decoder = CPUBatchDecoder(c2q, n_qubits)
+        decoder = CPUBatchDecoder(c2q, n_qubits)
         batch_fn = decoder.batch_decode
     else:
         decoder = UnionFindDecoder(c2q, n_qubits)
-
-        def _batch_decode_uf(batch: _np.ndarray) -> _np.ndarray:
-            out = _np.zeros((batch.shape[0], n_qubits), dtype=_np.uint8)
-            for i in range(batch.shape[0]):
-                out[i] = decoder.decode(batch[i])
-            return out
-
-        batch_fn = _batch_decode_uf
+        batch_fn = lambda batch: _np.array([decoder.decode(batch[i]) for i in range(batch.shape[0])])
 
     n_chunks = (n_shots + batch_size - 1) // batch_size
     for chunk_idx in range(n_chunks):

python/qector_decoder_v3/decoder_cache.py

@@ -29,24 +29,19 @@
 def _normalize_decoder_name(name: str) -> str:
     """Normalize decoder name aliases to canonical form."""
     mapping = {
-        "uf": "union_find",
-        "unionfind": "union_find",
-        "fast_uf": "fast_union_find",
-        "fastuf": "fast_union_find",
-        "fastunionfind": "fast_union_find",
-        "sparse": "sparse_blossom",
-        "batch": "cpu_batch",
-        "cpu": "cpu_batch",
+        'uf': 'union_find', 'unionfind': 'union_find',
+        'fast_uf': 'fast_union_find', 'fastuf': 'fast_union_find', 'fastunionfind': 'fast_union_find',
+        'sparse': 'sparse_blossom',
+        'batch': 'cpu_batch', 'cpu': 'cpu_batch',
     }
-    return mapping.get(name.lower().replace("-", "_").replace(" ", "_"), name)
+    return mapping.get(name.lower().replace('-', '_').replace(' ', '_'), name)
 
 
 @_functools.lru_cache(maxsize=256)
 def _build_decoder(checks_tuple: Tuple[Tuple[int, ...]], n_qubits: int, decoder_type: str):
     """Internal LRU-cached decoder factory."""
     checks = [list(c) for c in checks_tuple]
     from . import BlossomDecoder, CPUBatchDecoder, FastUnionFindDecoder, SparseBlossomDecoder, UnionFindDecoder
-
     builders = {
         "union_find": lambda: UnionFindDecoder(checks, n_qubits),
         "fast_union_find": lambda: FastUnionFindDecoder(checks, n_qubits),
@@ -96,7 +91,6 @@ def get_decoder_pool(
         A :class:`DecoderPool` instance.
     """
     from .decoder_pool import DecoderPool
-
     return DecoderPool(
         [list(c) for c in checks_tuple],
         n_qubits=n_qubits,

python/qector_decoder_v3/decoder_pool.py

@@ -29,10 +29,9 @@
 import multiprocessing as _mp
 import os
 import platform as _platform
-from typing import Optional
+from typing import List, Optional, cast
 
 import numpy as np
-from numpy.typing import NDArray
 
 __all__ = ["DecoderPool"]
 
@@ -46,7 +45,6 @@ def _worker_init(checks_tuple, n_qubits, decoder_type):
     global _WORKER_DECODER
     checks = [list(c) for c in checks_tuple]
     from . import BlossomDecoder, CPUBatchDecoder, FastUnionFindDecoder, SparseBlossomDecoder, UnionFindDecoder
-
     builders = {
         "union_find": lambda: UnionFindDecoder(checks, n_qubits),
         "fast_union_find": lambda: FastUnionFindDecoder(checks, n_qubits),
@@ -76,16 +74,10 @@ def _worker_decode(chunk_and_idx):
 
 
 _DECODER_BUILDERS = {
-    "union_find": lambda c2q, nq: __import__("qector_decoder_v3", fromlist=["UnionFindDecoder"]).UnionFindDecoder(
-        c2q, nq
-    ),
-    "fast_union_find": lambda c2q, nq: __import__(
-        "qector_decoder_v3", fromlist=["FastUnionFindDecoder"]
-    ).FastUnionFindDecoder(c2q, nq),
+    "union_find": lambda c2q, nq: __import__("qector_decoder_v3", fromlist=["UnionFindDecoder"]).UnionFindDecoder(c2q, nq),
+    "fast_union_find": lambda c2q, nq: __import__("qector_decoder_v3", fromlist=["FastUnionFindDecoder"]).FastUnionFindDecoder(c2q, nq),
     "blossom": lambda c2q, nq: __import__("qector_decoder_v3", fromlist=["BlossomDecoder"]).BlossomDecoder(c2q, nq),
-    "sparse_blossom": lambda c2q, nq: __import__(
-        "qector_decoder_v3", fromlist=["SparseBlossomDecoder"]
-    ).SparseBlossomDecoder(c2q, nq),
+    "sparse_blossom": lambda c2q, nq: __import__("qector_decoder_v3", fromlist=["SparseBlossomDecoder"]).SparseBlossomDecoder(c2q, nq),
     "cpu_batch": lambda c2q, nq: __import__("qector_decoder_v3", fromlist=["CPUBatchDecoder"]).CPUBatchDecoder(c2q, nq),
 }
 
@@ -119,7 +111,7 @@ def __init__(
         self._nq = int(n_qubits) if n_qubits is not None else None
         self._decoder_type = str(decoder_type)
         self._n_workers = n_workers or os.cpu_count() or 1
-        self._pool: Optional[_mp.pool.Pool] = None
+        self._pool: Optional["_mp.pool.Pool"] = None
 
     def decode(self, syndromes) -> np.ndarray:
         """Decode a batch of syndromes.
@@ -156,15 +148,14 @@ def decode(self, syndromes) -> np.ndarray:
                 initargs=(checks_tuple, self._nq, self._decoder_type),
             )
 
-        assert self._pool is not None
         nw = min(self._n_workers, n)
         chunk_size = (n + nw - 1) // nw
-        chunks = [(arr[i : i + chunk_size], i // chunk_size) for i in range(0, n, chunk_size)]
+        chunks = [(arr[i:i + chunk_size], i // chunk_size) for i in range(0, n, chunk_size)]
 
-        results: list[NDArray[np.uint8]] = [None] * len(chunks)  # type: ignore[list-item]
+        results: List[Optional[np.ndarray]] = [None] * len(chunks)
         for idx, result in self._pool.imap_unordered(_worker_decode, chunks):
             results[idx] = result
-        return np.concatenate(results, axis=0).astype(np.uint8)
+        return cast(np.ndarray, np.concatenate(cast(List[np.ndarray], results), axis=0).astype(np.uint8))
 
     def close(self):
         if self._pool is not None: