fix: resolve all 17 mypy type errors -- bulletproof PyPI release

- bposd.py: annotate n_checks/n_qubits as int; cast H.shape unpacking
- sinter_compat.py: type dynamic bases as 	ype; add type:ignore[misc,valid-type]
- predecoder.py: replace lambda dict with explicit if/elif for Union narrowing;
  add TYPE_CHECKING import for BlossomDecoder/UnionFindDecoder/SparseBlossomDecoder
- dem.py: guard None in state dict before arithmetic (max_det / max_obs)
- __init__.py: add device_name -> str property to OpenCLBatchDecoder
- backend.py: annotate timings dict; annotate gpu_dec as Optional Union;
  cast n_qubits to int() on n_qubits property
- rest_api.py: add Union import; split dec into dec_any + uf_dec so mypy
  narrows .decode() call correctly in both FastAPI and Flask branches
- qiskit_plugin.py: cast get_counts() through dict comprehension -> str/int
- pyproject.toml: bump mypy python_version 3.9->3.10 (mypy 2.x dropped 3.9);
  remove stale numpy.* overrides section (no numpy in mypy env)

Result: mypy --ignore-missing-imports: 0 errors in 16 files
        ruff check: all checks passed
        ruff format: 139 files unchanged

Author: qectorlab

pyproject.toml

@@ -111,17 +111,11 @@ filterwarnings = [
 ]
 
 [tool.mypy]
-python_version = "3.9"
+python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
 ignore_missing_imports = true
 
-# numpy 2.x stubs use `type` statement (Python 3.12+ syntax); ignore stub
-# errors from third-party packages so mypy only checks our own code.
-[[tool.mypy.overrides]]
-module = ["numpy", "numpy.*"]
-ignore_errors = true
-
 [tool.ruff]
 line-length = 120
 target-version = "py39"

python/qector_decoder_v3/__init__.py

@@ -392,6 +392,10 @@ def n_qubits(self):
     def n_checks(self):
         return self._inner.n_checks
 
+    @property
+    def device_name(self) -> str:
+        return str(self._inner.device_name)
+
     @property
     def consecutive_failures(self):
         """Number of consecutive GPU failures since last success."""
@@ -455,8 +459,8 @@ def n_checks(self):
         return self._inner.n_checks
 
     @property
-    def device_name(self):
-        return self._inner.device_name
+    def device_name(self) -> str:
+        return str(self._inner.device_name)
 
     @property
     def compute_capability(self):

python/qector_decoder_v3/backend.py

@@ -239,9 +239,9 @@ def calibrate(self, sizes=(64, 256, 1024, 4096, 16384), repeats: int = 3, seed:
         """
         rng = np.random.default_rng(seed)
         n_checks = len(self._c2q)
-        timings = {"cpu": {}, "gpu": {}}
+        timings: dict[str, dict[int, float]] = {"cpu": {}, "gpu": {}}
         gpu_name = None
-        gpu_dec = None
+        gpu_dec: Optional[CUDABatchDecoder | OpenCLBatchDecoder] = None
         if self._cuda_ok:
             gpu_dec, gpu_name = self._get_cuda(), Backend.CUDA
         elif self._opencl_ok:
@@ -308,7 +308,7 @@ def last_backend(self) -> str:
 
     @property
     def n_qubits(self) -> int:
-        return self._get_cpu_single().n_qubits
+        return int(self._get_cpu_single().n_qubits)
 
     @property
     def n_checks(self) -> int:

python/qector_decoder_v3/bposd.py

@@ -49,7 +49,9 @@ def __init__(
         self.H = _to_dense_binary(H)
         if self.H.ndim != 2:
             raise ValueError(f"H must be 2D, got {self.H.shape}")
-        self.n_checks, self.n_qubits = self.H.shape
+        self.n_checks: int
+        self.n_qubits: int
+        self.n_checks, self.n_qubits = (int(x) for x in self.H.shape)
         self.ic, self.ie = build_incidence(self.H)
         if priors is None:
             p = np.full(self.n_qubits, float(error_rate), dtype=np.float64)

python/qector_decoder_v3/dem.py

@@ -265,8 +265,8 @@ def parse_dem(text: str) -> DemModel:
     coords: dict = {}
     state = {"det_offset": 0, "coord_offset": None, "max_det": -1, "max_obs": -1}
     _exec_block(tokens, 0, len(tokens), state, errors, coords)
-    num_detectors = state["max_det"] + 1
-    num_observables = state["max_obs"] + 1
+    num_detectors = (state["max_det"] if state["max_det"] is not None else -1) + 1
+    num_observables = (state["max_obs"] if state["max_obs"] is not None else -1) + 1
     return DemModel(
         errors=errors,
         num_detectors=max(num_detectors, 0),

python/qector_decoder_v3/predecoder.py

@@ -23,10 +23,13 @@
 
 from __future__ import annotations
 
-from typing import List
+from typing import TYPE_CHECKING, List, Union
 
 import numpy as np
 
+if TYPE_CHECKING:
+    from . import BlossomDecoder, SparseBlossomDecoder, UnionFindDecoder
+
 __all__ = ["PredecodedDecoder", "quantize_weights"]
 
 
@@ -73,15 +76,18 @@ def __init__(self, check_to_qubits, n_qubits=None, backend: str = "blossom"):
                 key = (min(chk), max(chk))
                 self._pair_edge.setdefault(key, q)
 
-        builders = {
-            "blossom": lambda: BlossomDecoder(self._c2q, self.n_qubits),
-            "union_find": lambda: UnionFindDecoder(self._c2q, self.n_qubits),
-            "sparse_blossom": lambda: SparseBlossomDecoder(self._c2q, self.n_qubits),
-        }
-        if backend not in builders:
-            raise ValueError(f"backend must be one of {list(builders)}")
+        _valid_backends = ("blossom", "union_find", "sparse_blossom")
+        if backend not in _valid_backends:
+            raise ValueError(f"backend must be one of {list(_valid_backends)}")
         self.backend = backend
-        self._residual = builders[backend]()
+        residual: Union[BlossomDecoder, UnionFindDecoder, SparseBlossomDecoder]
+        if backend == "blossom":
+            residual = BlossomDecoder(self._c2q, self.n_qubits)
+        elif backend == "union_find":
+            residual = UnionFindDecoder(self._c2q, self.n_qubits)
+        else:
+            residual = SparseBlossomDecoder(self._c2q, self.n_qubits)
+        self._residual: Union[BlossomDecoder, UnionFindDecoder, SparseBlossomDecoder] = residual
         self.last_predecoded = 0  # number of defects resolved by the predecoder
 
     def _predecode(self, syndrome: np.ndarray):

python/qector_decoder_v3/qiskit_plugin.py

@@ -50,7 +50,7 @@ def _normalize_counts(result: Any) -> Dict[str, int]:
 
     if _HAS_QISKIT and isinstance(result, _QiskitResult):
         # get_counts() retourne un dict {bitstring: count}
-        return result.get_counts()
+        return {str(k): int(v) for k, v in result.get_counts().items()}
 
     raise TypeError(f"result must be a dict or qiskit.result.Result, got {type(result).__name__}")
 

python/qector_decoder_v3/rest_api.py

@@ -23,7 +23,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
 
@@ -89,21 +89,23 @@ async def decode_endpoint(req: DecodeRequest) -> Dict[str, Any]:  # type: ignore
             raise HTTPException(status_code=400, detail="check_to_qubits must be non-empty")
 
         try:
+            dec_any: Union[BatchDecoder, UnionFindDecoder]
             if req.use_batch:
-                dec = BatchDecoder(req.check_to_qubits, req.n_qubits)
+                dec_any = BatchDecoder(req.check_to_qubits, req.n_qubits)
                 syndrome_arr = np.array([req.syndrome], dtype=np.uint8)
-                correction = dec.parallel_batch_decode(syndrome_arr)[0]
+                correction = dec_any.parallel_batch_decode(syndrome_arr)[0]
             else:
-                dec = UnionFindDecoder(req.check_to_qubits, req.n_qubits)
+                uf_dec = UnionFindDecoder(req.check_to_qubits, req.n_qubits)
+                dec_any = uf_dec
                 syndrome_arr = np.array(req.syndrome, dtype=np.uint8)
-                correction = dec.decode(syndrome_arr)
+                correction = uf_dec.decode(syndrome_arr)
         except Exception as exc:
             raise HTTPException(status_code=500, detail=f"Decode error: {exc}")
 
         return {
             "correction": correction.tolist(),
-            "n_qubits": dec.n_qubits,
-            "n_checks": dec.n_checks,
+            "n_qubits": dec_any.n_qubits,
+            "n_checks": dec_any.n_checks,
             "version": __version__,
         }
 
@@ -142,22 +144,24 @@ def decode_endpoint() -> Any:
             return jsonify({"error": "check_to_qubits must be non-empty"}), 400
 
         try:
+            dec_any: Union[BatchDecoder, UnionFindDecoder]
             if use_batch:
-                dec = BatchDecoder(c2q, n_qubits)
+                dec_any = BatchDecoder(c2q, n_qubits)
                 syndrome_arr = np.array([syndrome], dtype=np.uint8)
-                correction = dec.parallel_batch_decode(syndrome_arr)[0]
+                correction = dec_any.parallel_batch_decode(syndrome_arr)[0]
             else:
-                dec = UnionFindDecoder(c2q, n_qubits)
+                uf_dec = UnionFindDecoder(c2q, n_qubits)
+                dec_any = uf_dec
                 syndrome_arr = np.array(syndrome, dtype=np.uint8)
-                correction = dec.decode(syndrome_arr)
+                correction = uf_dec.decode(syndrome_arr)
         except Exception as exc:
             return jsonify({"error": f"Decode error: {exc}"}), 500
 
         return jsonify(
             {
                 "correction": correction.tolist(),
-                "n_qubits": dec.n_qubits,
-                "n_checks": dec.n_checks,
+                "n_qubits": dec_any.n_qubits,
+                "n_checks": dec_any.n_checks,
                 "version": __version__,
             }
         )

python/qector_decoder_v3/sinter_compat.py

@@ -24,25 +24,28 @@
 
 from __future__ import annotations
 
-from typing import Dict
+from typing import TYPE_CHECKING, Dict
 
 import numpy as np
 
+if TYPE_CHECKING:
+    pass  # sinter types used only at runtime
+
 __all__ = ["QectorSinterDecoder", "qector_sinter_decoders"]
 
 try:
     import sinter
 
-    _SINTER_BASE = sinter.Decoder
-    _COMPILED_BASE = sinter.CompiledDecoder
+    _SINTER_BASE: type = sinter.Decoder
+    _COMPILED_BASE: type = sinter.CompiledDecoder
     _HAS_SINTER = True
 except Exception:  # pragma: no cover - sinter optional
     _SINTER_BASE = object
     _COMPILED_BASE = object
     _HAS_SINTER = False
 
 
-class _CompiledQectorDecoder(_COMPILED_BASE):
+class _CompiledQectorDecoder(_COMPILED_BASE):  # type: ignore[misc,valid-type]
     """A compiled QECTOR decoder bound to one detector error model."""
 
     def __init__(self, matcher, num_detectors: int, num_observables: int):
@@ -70,7 +73,7 @@ def decode_shots_bit_packed(self, *, bit_packed_detection_event_data: np.ndarray
         return np.packbits(preds, axis=1, bitorder="little")
 
 
-class QectorSinterDecoder(_SINTER_BASE):
+class QectorSinterDecoder(_SINTER_BASE):  # type: ignore[misc,valid-type]
     """A Sinter ``Decoder`` backed by QECTOR.
 
     ``kind`` selects the backend: ``"blossom"`` (weighted exact MWPM),