style: ruff format entire python/ tree (128 files)

Author: qectorlab

python/qector_decoder_v3/__init__.py

@@ -40,12 +40,15 @@
     def cuda_is_available():
         return False
 
+
 try:
     from .qector_decoder_v3 import opencl_is_available
 except ImportError:
+
     def opencl_is_available():
         return False
 
+
 try:
     from .qector_decoder_v3 import run_grpc_server
 except ImportError:
@@ -64,10 +67,9 @@ def opencl_is_available():
     __version__ = "0.5.0"
 
 
-
 class UnionFindDecoder:
     """Production-ready Union-Find quantum error correction decoder.
-    
+
     Rust core with PyO3 bindings. Zero-copy NumPy interop.
     GIL is released during decode for true parallelism.
     """
@@ -242,7 +244,7 @@ def current_round(self):
 
 class StreamingDecoder:
     """Streaming decoder that accumulates syndromes over multiple rounds.
-    
+
     Rust core with circular history buffer and OR accumulation.
     """
 
@@ -281,7 +283,7 @@ def n_checks(self):
 
 class BatchDecoder:
     """Parallel batch decoder using Rayon (Rust data parallelism).
-    
+
     Distributes batch decoding across all CPU cores.
     """
 
@@ -486,7 +488,7 @@ def is_available():
 
 class SparseBlossomDecoder:
     """Region-growing Sparse Blossom decoder with RadixHeap.
-    
+
     Supports dynamic weight overrides from GNN Pre-Decoder for enriched decoding.
     """
 
@@ -506,11 +508,11 @@ def decode(self, syndrome):
 
     def decode_with_weights(self, syndrome, weights):
         """Decode with per-qubit dynamic weight overrides.
-        
+
         Args:
             syndrome: np.ndarray of shape (n_checks,) with dtype uint8.
             weights: List of (qubit_id, weight) tuples.
-        
+
         Returns:
             np.ndarray of shape (n_qubits,) with correction.
         """
@@ -542,7 +544,7 @@ def n_checks(self):
 
 class BPOSDDecoder:
     """Belief Propagation + Ordered Statistics Decoding.
-    
+
     Min-sum BP with OSD stage for improved LER on complex codes.
     """
 
@@ -630,9 +632,9 @@ class GNNPredecoder:
     """Graph Neural Network Pre-Decoder for dynamic edge weight prediction.
 
     MPNN 3 layers + MLP readout. Predicts adjusted edge weights for SparseBlossom.
-    
+
     **v2.0** : Full backpropagation through MPNN layers (P0). All layers are trainable.
-    
+
     Dimensions must match the DetectorGraph:
     - node_feat_dim = 10 (NodeFeatures::DIM)
     - edge_feat_dim = 8 (EdgeFeatures::DIM)
@@ -644,7 +646,7 @@ class GNNPredecoder:
 
     def __init__(self, node_feat_dim=None, edge_feat_dim=None, hidden_size=16, n_layers=2):
         """Create a GNNPredecoder.
-        
+
         If node_feat_dim and edge_feat_dim are not provided, uses the standard
         dimensions matching DetectorGraph (10 and 8).
         """
@@ -763,19 +765,28 @@ def generate_dataset(self, n_samples):
 
 class HybridDecoder:
     """GNN Pre-Decoder + SparseBlossom hybrid decoder.
-    
+
     Uses a lightweight MPNN to estimate dynamic edge weights, then passes
     them to SparseBlossom for enriched region-growing decoding.
     """
 
-    def __init__(self, check_to_qubits, n_qubits=None, check_positions=None,
-                 check_types=None, base_weights=None, gnn_hidden_size=64, gnn_n_layers=3):
+    def __init__(
+        self,
+        check_to_qubits,
+        n_qubits=None,
+        check_positions=None,
+        check_types=None,
+        base_weights=None,
+        gnn_hidden_size=64,
+        gnn_n_layers=3,
+    ):
         if not check_to_qubits:
             raise ValueError("check_to_qubits must be non-empty")
         c2q = [[int(q) for q in check] for check in check_to_qubits]
         nq = None if n_qubits is None else int(n_qubits)
-        self._inner = _RustHybridDecoder(c2q, nq, check_positions, check_types,
-                                         base_weights, gnn_hidden_size, gnn_n_layers)
+        self._inner = _RustHybridDecoder(
+            c2q, nq, check_positions, check_types, base_weights, gnn_hidden_size, gnn_n_layers
+        )
 
     def decode_hybrid(self, syndrome):
         if not isinstance(syndrome, np.ndarray):
@@ -965,12 +976,14 @@ def __init__(self, check_to_qubits, n_qubits=None, n_samples=10000, seed=42):
 
     def run(self):
         import json
+
         raw = self._inner.run()
         return json.loads(raw)
 
     def save(self, path, results):
         import json
         from pathlib import Path
+
         Path(path).write_text(json.dumps(results, indent=2), encoding="utf-8")
 
 

python/qector_decoder_v3/backend.py

@@ -168,11 +168,7 @@ def select(self, batch_size: int) -> str:
         """Return the backend that *would* run for a given batch size."""
         if self.config.force is not None:
             return self.config.force
-        if (
-            self.config.allow_gpu
-            and batch_size >= self.config.gpu_threshold
-            and (self._cuda_ok or self._opencl_ok)
-        ):
+        if self.config.allow_gpu and batch_size >= self.config.gpu_threshold and (self._cuda_ok or self._opencl_ok):
             if self.config.prefer == Backend.OPENCL and self._opencl_ok:
                 return Backend.OPENCL
             if self._cuda_ok:
@@ -271,9 +267,7 @@ def calibrate(self, sizes=(64, 256, 1024, 4096, 16384), repeats: int = 3, seed:
             self._diag.warnings.append("no GPU available for calibration; GPU disabled")
             self.config.gpu_threshold = 1 << 62
         elif crossover is None:
-            self._diag.warnings.append(
-                "GPU never beat CPU in calibration; keeping CPU for all sizes"
-            )
+            self._diag.warnings.append("GPU never beat CPU in calibration; keeping CPU for all sizes")
             self.config.gpu_threshold = 1 << 62
         else:
             self.config.gpu_threshold = int(crossover)

python/qector_decoder_v3/belief_matching.py

@@ -46,12 +46,12 @@
 
 @dataclass
 class _Matrices:
-    hyper_check: np.ndarray          # (num_detectors, num_hyper)
-    hyper_obs: np.ndarray            # (num_observables, num_hyper)
-    hyper_priors: np.ndarray         # (num_hyper,)
-    hyper_to_edge: np.ndarray        # (num_edges, num_hyper)
-    edge_check: np.ndarray           # (num_detectors, num_edges)
-    edge_obs: np.ndarray             # (num_observables, num_edges)
+    hyper_check: np.ndarray  # (num_detectors, num_hyper)
+    hyper_obs: np.ndarray  # (num_observables, num_hyper)
+    hyper_priors: np.ndarray  # (num_hyper,)
+    hyper_to_edge: np.ndarray  # (num_edges, num_hyper)
+    edge_check: np.ndarray  # (num_detectors, num_edges)
+    edge_obs: np.ndarray  # (num_observables, num_edges)
     num_detectors: int
     num_observables: int
 
@@ -148,8 +148,7 @@ def handle(prob: float, dets: List[List[int]], frames: List[List[int]]):
     for hid, p in priors.items():
         prior_arr[hid] = p
 
-    return _Matrices(hyper_check, hyper_obs_m, prior_arr, hyper_to_edge, edge_check,
-                     edge_obs_m, nD, nO)
+    return _Matrices(hyper_check, hyper_obs_m, prior_arr, hyper_to_edge, edge_check, edge_obs_m, nD, nO)
 
 
 class BeliefMatching:
@@ -176,8 +175,7 @@ def __init__(self, matrices: _Matrices, max_iter: int = 30, bp_shortcut: bool =
         # Matching graph = edge check matrix.
         self._n_edges = matrices.edge_check.shape[1]
         self._edge_c2q: List[List[int]] = [
-            sorted(int(e) for e in np.nonzero(matrices.edge_check[c])[0])
-            for c in range(self.n_checks)
+            sorted(int(e) for e in np.nonzero(matrices.edge_check[c])[0]) for c in range(self.n_checks)
         ]
 
     # -- constructors ------------------------------------------------------
@@ -187,9 +185,7 @@ def from_detector_error_model(cls, dem: Any, max_iter: int = 20) -> "BeliefMatch
 
     @classmethod
     def from_stim_circuit(cls, circuit, max_iter: int = 20) -> "BeliefMatching":
-        return cls.from_detector_error_model(
-            circuit.detector_error_model(decompose_errors=True), max_iter=max_iter
-        )
+        return cls.from_detector_error_model(circuit.detector_error_model(decompose_errors=True), max_iter=max_iter)
 
     # -- decoding ----------------------------------------------------------
     def decode(self, syndrome) -> np.ndarray:
@@ -198,8 +194,13 @@ def decode(self, syndrome) -> np.ndarray:
             s = np.concatenate([s, np.zeros(self.n_checks - s.shape[0], np.uint8)])
 
         posterior = sum_product_bp(
-            self._hic, self._hie, self.n_checks, self._n_hyper,
-            self._prior_llr, s, self.max_iter,
+            self._hic,
+            self._hie,
+            self.n_checks,
+            self._n_hyper,
+            self._prior_llr,
+            s,
+            self.max_iter,
         )
         if self.bp_shortcut:
             hard = (posterior < 0.0).astype(np.uint8)

python/qector_decoder_v3/benchmarking.py

@@ -110,9 +110,7 @@ def git_commit() -> str:
 
 def _safe_cmd(cmd: Sequence[str]) -> Optional[str]:
     try:
-        out = subprocess.run(
-            list(cmd), capture_output=True, text=True, timeout=10, check=False
-        )
+        out = subprocess.run(list(cmd), capture_output=True, text=True, timeout=10, check=False)
         return out.stdout.strip() or None
     except Exception:  # pragma: no cover
         return None
@@ -166,7 +164,7 @@ def summarize(samples_seconds: Sequence[float]) -> Dict[str, float]:
     mean = float(us.mean())
     std = float(us.std(ddof=1)) if n > 1 else 0.0
     # 95% normal CI on the mean.
-    half = 1.959963985 * std / (n ** 0.5) if n > 1 else 0.0
+    half = 1.959963985 * std / (n**0.5) if n > 1 else 0.0
     summary = {
         "n": int(n),
         "mean": mean,
@@ -184,9 +182,7 @@ def summarize(samples_seconds: Sequence[float]) -> Dict[str, float]:
 # ---------------------------------------------------------------------------
 # Timing primitives
 # ---------------------------------------------------------------------------
-def time_iterations(
-    fn: Callable[[], Any], n_trials: int, warmup: int = 0
-) -> List[float]:
+def time_iterations(fn: Callable[[], Any], n_trials: int, warmup: int = 0) -> List[float]:
     """Time ``fn`` per-call ``n_trials`` times after ``warmup`` untimed calls."""
     for _ in range(max(0, warmup)):
         fn()
@@ -296,9 +292,7 @@ def one_decode():
         "syndrome_faithful": valid,
         "cold_path_us": summarize(cold_samples),
         "latency_us": summarize(hot_samples),
-        "throughput_decodes_per_s": (1.0 / statistics.median(hot_samples))
-        if hot_samples
-        else None,
+        "throughput_decodes_per_s": (1.0 / statistics.median(hot_samples)) if hot_samples else None,
         "peak_python_alloc_kib": peak_kib,
     }
     return report

python/qector_decoder_v3/bposd.py

@@ -72,13 +72,24 @@ def decode(self, syndrome) -> np.ndarray:
             s = np.concatenate([s, np.zeros(self.n_checks - s.shape[0], np.uint8)])
         if self.bp_method == "sum_product":
             posterior = sum_product_bp(
-                self.ic, self.ie, self.n_checks, self.n_qubits,
-                self.prior_llr, s, self.max_iter,
+                self.ic,
+                self.ie,
+                self.n_checks,
+                self.n_qubits,
+                self.prior_llr,
+                s,
+                self.max_iter,
             )
         else:
             posterior = min_sum_bp(
-                self.ic, self.ie, self.n_checks, self.n_qubits,
-                self.prior_llr, s, self.max_iter, self.ms_scale,
+                self.ic,
+                self.ie,
+                self.n_checks,
+                self.n_qubits,
+                self.prior_llr,
+                s,
+                self.max_iter,
+                self.ms_scale,
             )
         hard = (posterior < 0.0).astype(np.uint8)
         if np.array_equal((self.H @ hard) & 1, s):

python/qector_decoder_v3/dem.py

@@ -138,9 +138,7 @@ def collapse_to_graph(self) -> "DemModel":
             for m in members:
                 p = p * (1.0 - m.probability) + m.probability * (1.0 - p)
             best = min(members, key=lambda m: m.weight)  # lowest weight == most likely
-            merged.append(
-                DemError(probability=p, detectors=sig, observables=best.observables)
-            )
+            merged.append(DemError(probability=p, detectors=sig, observables=best.observables))
 
         return DemModel(
             errors=merged,
@@ -234,9 +232,7 @@ def predicted_observables(self, correction: Sequence[int]) -> np.ndarray:
         """Logical observable flips implied by a correction (``L @ c mod 2``)."""
         c = np.asarray(correction, dtype=np.uint8).reshape(-1)
         if c.shape[0] != self.num_errors:
-            raise ValueError(
-                f"correction has length {c.shape[0]}, expected {self.num_errors}"
-            )
+            raise ValueError(f"correction has length {c.shape[0]}, expected {self.num_errors}")
         return (self.observables_matrix() @ c) & 1
 
     def __repr__(self) -> str:  # pragma: no cover - cosmetic
@@ -397,9 +393,7 @@ def _exec_instruction(tok: str, state: dict, errors: List[DemError], coords: dic
                 state["max_det"] = max(state["max_det"], d)
                 if coord_str:
                     try:
-                        coords[d] = tuple(
-                            float(x) for x in coord_str.split(",") if x.strip()
-                        )
+                        coords[d] = tuple(float(x) for x in coord_str.split(",") if x.strip())
                     except ValueError:
                         pass
         return
@@ -450,9 +444,7 @@ def from_stim(dem: Any) -> DemModel:
     if isinstance(dem, str):
         return parse_dem(dem)
     if not hasattr(dem, "num_detectors"):
-        raise TypeError(
-            f"expected a stim.DetectorErrorModel (or DEM text), got {type(dem).__name__}"
-        )
+        raise TypeError(f"expected a stim.DetectorErrorModel (or DEM text), got {type(dem).__name__}")
     try:
         flat = dem.flattened()
     except Exception:  # pragma: no cover - older Stim

python/qector_decoder_v3/pymatching_compat.py

@@ -132,9 +132,7 @@ def add_edge(
         self._num_detectors = max(self._num_detectors, int(node1) + 1, int(node2) + 1)
         self._decoder = None
 
-    def add_boundary_edge(
-        self, node: int, fault_ids: Any = None, weight: float = 1.0, **_: Any
-    ) -> None:
+    def add_boundary_edge(self, node: int, fault_ids: Any = None, weight: float = 1.0, **_: Any) -> None:
         """Add an edge from a detector node to the boundary."""
         self._edges.append(
             {
@@ -167,10 +165,7 @@ def num_fault_ids(self) -> int:
 
     def edges(self) -> List[Tuple[Optional[int], Optional[int], dict]]:
         """PyMatching-style edge list: ``(u, v, {"fault_ids":..., "weight":...})``."""
-        return [
-            (e["u"], e["v"], {"fault_ids": set(e["fault_ids"]), "weight": e["weight"]})
-            for e in self._edges
-        ]
+        return [(e["u"], e["v"], {"fault_ids": set(e["fault_ids"]), "weight": e["weight"]}) for e in self._edges]
 
     def check_matrix(self) -> np.ndarray:
         """The parity-check matrix (rows=detectors, cols=edges)."""
@@ -198,9 +193,7 @@ def _ensure_decoder(self) -> BlossomDecoder:
             # weights are equal, pass None so the uniform-weight fast path runs.
             weights = [e["weight"] for e in self._edges]
             uniform = len(set(round(w, 12) for w in weights)) <= 1
-            self._decoder = BlossomDecoder(
-                c2q, len(self._edges), None if uniform else weights
-            )
+            self._decoder = BlossomDecoder(c2q, len(self._edges), None if uniform else weights)
         return self._decoder
 
     def _edge_correction(self, syndrome: np.ndarray) -> np.ndarray: