fix: CI failures — ruff format, version sync, mypy type narrowing

- 44 files reformatted by ruff
- CITATION.cff and .zenodo.json version synced to 0.19.0
- QProfile args cast to float64 for mypy NDArray compatibility

Co-Authored-By: Arcane Sapience <protoscience@anulum.li>

Author: anulum

.zenodo.json

@@ -1,6 +1,6 @@
 {
   "title": "SCPN Control: Neuro-Symbolic Stochastic Petri Net Controller for Plasma Control",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Standalone neuro-symbolic control engine that compiles Stochastic Petri Nets into spiking neural network controllers with contract-based verification. Features full Grad-Shafranov equilibrium solver (fixed + free boundary, JAX-differentiable), three-path gyrokinetic transport (native linear eigenvalue solver + 5 external GK code interfaces + hybrid surrogate+GK validation with OOD detection and online learning), ballooning eigenvalue solver, sawtooth Kadomtsev crash model, NTM dynamics, current diffusion/drive, SOL two-point model, H-infinity/mu-synthesis/NMPC/gain-scheduled/sliding-mode/fault-tolerant controllers, safe RL (PPO 500K), scenario scheduling, real-time EFIT, shape control, integrated scenario simulator, QLKNN neural transport surrogate, adaptive Kuramoto coupling with GK-driven K_nm bridge, Lyapunov guard, and WebSocket streaming. 98 Python modules, 5 Rust crates, 3,015 tests (100% coverage), 20 CI jobs.",
   "upload_type": "software",
   "publication_date": "2026-03-13",

CITATION.cff

@@ -13,7 +13,7 @@ authors:
   - family-names: "Sotek"
     given-names: "Miroslav"
     orcid: "https://orcid.org/0009-0009-3560-0851"
-version: "0.18.0"
+version: "0.19.0"
 date-released: "2026-03-14"
 license: "AGPL-3.0-or-later"
 repository-code: "https://github.com/anulum/scpn-control"

benches/bench_fusion_snn_hook.py

@@ -8,6 +8,7 @@
 Run: pytest benches/bench_fusion_snn_hook.py -v
 Requires: pytest-benchmark
 """
+
 from __future__ import annotations
 
 import json
@@ -19,6 +20,7 @@
 
 # ── Minimal LIF layer (mirrors SNN controller hot path) ──────────────
 
+
 class LIFLayer:
     """Minimal LIF population for benchmarking."""
 
@@ -50,23 +52,27 @@ def rate_to_psi(spikes: np.ndarray, nu_max: float = 100.0) -> float:
 
 # ── Benchmarks ────────────────────────────────────────────────────────
 
+
 @pytest.fixture
 def rng():
     return np.random.default_rng(42)
 
 
 class TestFusionSNNHookBench:
-
     @pytest.mark.benchmark(group="phase_sync_step")
     @pytest.mark.parametrize("N", [256, 1000, 4096])
     def test_phase_sync_step_only(self, benchmark, rng, N):
         theta = rng.uniform(-np.pi, np.pi, N)
         omega = rng.normal(0, 0.5, N)
         benchmark(
             kuramoto_sakaguchi_step,
-            theta, omega,
-            dt=1e-3, K=2.0, zeta=0.5,
-            psi_driver=0.3, psi_mode="external",
+            theta,
+            omega,
+            dt=1e-3,
+            K=2.0,
+            zeta=0.5,
+            psi_driver=0.3,
+            psi_mode="external",
         )
 
     @pytest.mark.benchmark(group="snn_lif_step")
@@ -89,17 +95,20 @@ def closed_loop_tick():
             nonlocal theta, psi
             # Kuramoto step with current Ψ
             out = kuramoto_sakaguchi_step(
-                theta, omega, dt=1e-3, K=2.0, zeta=0.5,
-                psi_driver=psi, psi_mode="external",
+                theta,
+                omega,
+                dt=1e-3,
+                K=2.0,
+                zeta=0.5,
+                psi_driver=psi,
+                psi_mode="external",
             )
             theta = out["theta1"]
             R = out["R"]
             psi_r = out["Psi_r"]
 
             # Inject Kuramoto coherence into SNN synaptic current
-            i_syn = 10.0 + 5.0 * R * np.cos(
-                psi_r - np.linspace(0, 2 * np.pi, N_lif, endpoint=False)
-            )
+            i_syn = 10.0 + 5.0 * R * np.cos(psi_r - np.linspace(0, 2 * np.pi, N_lif, endpoint=False))
             spikes = lif.step(i_syn)
 
             # Decode spike rate → Ψ for next tick
@@ -121,13 +130,16 @@ def run_100():
             psi = 0.0
             for _ in range(100):
                 out = kuramoto_sakaguchi_step(
-                    theta, omega, dt=1e-4, K=2.0, zeta=0.5,
-                    psi_driver=psi, psi_mode="external",
+                    theta,
+                    omega,
+                    dt=1e-4,
+                    K=2.0,
+                    zeta=0.5,
+                    psi_driver=psi,
+                    psi_mode="external",
                 )
                 theta = out["theta1"]
-                i_syn = 10.0 + 5.0 * out["R"] * np.cos(
-                    out["Psi_r"] - np.linspace(0, 2 * np.pi, N_lif, endpoint=False)
-                )
+                i_syn = 10.0 + 5.0 * out["R"] * np.cos(out["Psi_r"] - np.linspace(0, 2 * np.pi, N_lif, endpoint=False))
                 spikes = lif.step(i_syn)
                 psi = rate_to_psi(spikes)
             return out["R"]
@@ -149,6 +161,7 @@ def test_fusion_kernel_phase_sync(self, benchmark, rng, tmp_path):
         cfg_path = tmp_path / "bench.json"
         cfg_path.write_text(json.dumps(cfg))
         from scpn_control.core.fusion_kernel import FusionKernel
+
         kernel = FusionKernel(str(cfg_path))
 
         N = 1000

benchmarks/e2e_control_latency.py

@@ -19,11 +19,11 @@
     python benchmarks/e2e_control_latency.py --json
     python benchmarks/e2e_control_latency.py --iterations 5000
 """
+
 from __future__ import annotations
 
 import argparse
 import json
-import sys
 import tempfile
 import time
 from pathlib import Path
@@ -90,9 +90,7 @@ def bench_e2e(transport, hinf, n_warmup: int, n_iter: int) -> np.ndarray:
     times_ns = np.empty(n_iter, dtype=np.int64)
     for i in range(n_iter):
         t0 = time.perf_counter_ns()
-        u_prev = _e2e_iteration(
-            transport, hinf, rng, source, dt_transport, dt_control, P_aux, u_max, slew_max, u_prev
-        )
+        u_prev = _e2e_iteration(transport, hinf, rng, source, dt_transport, dt_control, P_aux, u_max, slew_max, u_prev)
         times_ns[i] = time.perf_counter_ns() - t0
     return times_ns
 
@@ -174,7 +172,7 @@ def main():
     print(f"  Iterations: {args.iterations}   Warmup: {args.warmup}   Grid: 16x16")
     print()
     print(f"  {'Stage':<30} {'P50 µs':>8} {'P95 µs':>8} {'P99 µs':>8}")
-    print(f"  {'-'*30} {'-'*8} {'-'*8} {'-'*8}")
+    print(f"  {'-' * 30} {'-' * 8} {'-' * 8} {'-' * 8}")
     for label, key in [("Kernel only (1 SOR step)", "kernel_only_us"), ("Full E2E control cycle", "e2e_us")]:
         d = results[key]
         print(f"  {label:<30} {d['p50']:>8.1f} {d['p95']:>8.1f} {d['p99']:>8.1f}")

check_activated_features.py

@@ -2,6 +2,7 @@
 import numpy as np
 import scpn_control_rs as rs
 
+
 def main():
     print("SCPN-CONTROL: Activated Feature Verification")
     print("-" * 40)
@@ -16,15 +17,15 @@ def main():
     t0 = time.perf_counter()
     x = rs.py_thomas_solve(a, b, c, d)
     t1 = time.perf_counter()
-    print(f"Thomas Solver: {(t1-t0)*1e6:.2f} us (size 10)")
+    print(f"Thomas Solver: {(t1 - t0) * 1e6:.2f} us (size 10)")
 
     # 2. X-Point search
     grid_r = np.linspace(1.0, 9.0, 129)
     grid_z = np.linspace(-5.0, 5.0, 129)
     psi = np.zeros((129, 129))
     # Gaussian at (5.0, -3.0)
     RR, ZZ = np.meshgrid(grid_r, grid_z)
-    psi = ((RR - 5.0)**2 + (ZZ + 3.0)**2)
+    psi = (RR - 5.0) ** 2 + (ZZ + 3.0) ** 2
 
     t0 = time.perf_counter()
     fk_tmp = rs.PyFusionKernel("iter_config.json")
@@ -38,7 +39,7 @@ def main():
     t0 = time.perf_counter()
     br, bz = fk.compute_b_field()
     t1 = time.perf_counter()
-    print(f"B-Field Compute (129x129): {(t1-t0)*1e6:.2f} us")
+    print(f"B-Field Compute (129x129): {(t1 - t0) * 1e6:.2f} us")
 
     # 4. AMR Solve (New!)
     amr = rs.PyAmrSolver(max_levels=2, coarse_iters=100)
@@ -48,7 +49,8 @@ def main():
     t0 = time.perf_counter()
     psi_amr = amr.solve_with_hierarchy(psi, grid_r, grid_z)
     t1 = time.perf_counter()
-    print(f"AMR Equilibrium Solve: {(t1-t0):.4f} s")
+    print(f"AMR Equilibrium Solve: {(t1 - t0):.4f} s")
+
 
 if __name__ == "__main__":
     main()

dashboard/scpn_studio.py

@@ -3,6 +3,7 @@
 
 Runs Kuramoto-Sakaguchi phase dynamics via scpn-control (no inlined engine).
 """
+
 from __future__ import annotations
 
 import threading
@@ -37,10 +38,7 @@ def _tick_loop(monitor: RealtimeMonitor, buf: deque, stop_ev: threading.Event):
 
 # -- Header --
 st.title("SCPN Phase Sync")
-st.caption(
-    "Kuramoto-Sakaguchi mean-field | Paper 27 Knm coupling | "
-    "[GitHub](https://github.com/anulum/scpn-control)"
-)
+st.caption("Kuramoto-Sakaguchi mean-field | Paper 27 Knm coupling | [GitHub](https://github.com/anulum/scpn-control)")
 
 # -- Sidebar --
 with st.sidebar:
@@ -62,8 +60,10 @@ def _tick_loop(monitor: RealtimeMonitor, buf: deque, stop_ev: threading.Event):
         st.session_state.stop.clear()
         st.session_state.buffer.clear()
         monitor = RealtimeMonitor.from_paper27(
-            L=layers, N_per=n_per,
-            zeta_uniform=zeta, psi_driver=psi,
+            L=layers,
+            N_per=n_per,
+            zeta_uniform=zeta,
+            psi_driver=psi,
         )
         st.session_state.thread = threading.Thread(
             target=_tick_loop,
@@ -78,13 +78,14 @@ def _tick_loop(monitor: RealtimeMonitor, buf: deque, stop_ev: threading.Event):
         st.session_state.running = False
 
 # -- Auto-start on first visit with defaults --
-if not st.session_state.running and (
-    st.session_state.thread is None or not st.session_state.thread.is_alive()
-):
+if not st.session_state.running and (st.session_state.thread is None or not st.session_state.thread.is_alive()):
     st.session_state.stop.clear()
     st.session_state.buffer.clear()
     monitor = RealtimeMonitor.from_paper27(
-        L=16, N_per=50, zeta_uniform=0.5, psi_driver=0.0,
+        L=16,
+        N_per=50,
+        zeta_uniform=0.5,
+        psi_driver=0.0,
     )
     st.session_state.thread = threading.Thread(
         target=_tick_loop,
@@ -98,9 +99,7 @@ def _tick_loop(monitor: RealtimeMonitor, buf: deque, stop_ev: threading.Event):
 # -- Main --
 frames = list(st.session_state.buffer)
 is_live = (
-    st.session_state.thread is not None
-    and st.session_state.thread.is_alive()
-    and not st.session_state.stop.is_set()
+    st.session_state.thread is not None and st.session_state.thread.is_alive() and not st.session_state.stop.is_set()
 )
 
 c1, c2 = st.columns(2)
@@ -128,8 +127,10 @@ def _tick_loop(monitor: RealtimeMonitor, buf: deque, stop_ev: threading.Event):
 # -- Charts --
 try:
     import matplotlib
+
     matplotlib.use("Agg")
     import matplotlib.pyplot as plt
+
     HAS_MPL = True
 except ImportError:
     HAS_MPL = False

examples/advanced_control_demo.ipynb

@@ -125,9 +125,7 @@
    "outputs": [],
    "source": [
     "from scpn_control.control.gain_scheduled_controller import (\n",
-    "    GainScheduledController,\n",
     "    RegimeDetector,\n",
-    "    RegimeController,\n",
     "    OperatingRegime,\n",
     ")\n",
     "\n",
@@ -227,9 +225,11 @@
     "\n",
     "# Check stabilization at beta_N = 3.5\n",
     "rwm_test = RWMPhysics(3.5, beta_nowall, beta_wall, tau_wall)\n",
-    "print(f\"beta_N=3.5: unstable={rwm_test.is_unstable()}, \"\n",
-    "      f\"gamma_open={rwm_test.growth_rate():.1f} s^-1, \"\n",
-    "      f\"stabilized={ctrl_rwm.is_stabilized(rwm_test)}\")"
+    "print(\n",
+    "    f\"beta_N=3.5: unstable={rwm_test.is_unstable()}, \"\n",
+    "    f\"gamma_open={rwm_test.growth_rate():.1f} s^-1, \"\n",
+    "    f\"stabilized={ctrl_rwm.is_stabilized(rwm_test)}\"\n",
+    ")"
    ]
   },
   {
@@ -258,10 +258,12 @@
     ")\n",
     "\n",
     "# Define uncertainty blocks\n",
-    "uncertainty = StructuredUncertainty([\n",
-    "    UncertaintyBlock(\"plasma_current\", size=1, bound=0.1, block_type=\"real\"),\n",
-    "    UncertaintyBlock(\"wall_position\", size=1, bound=0.2, block_type=\"complex\"),\n",
-    "])\n",
+    "uncertainty = StructuredUncertainty(\n",
+    "    [\n",
+    "        UncertaintyBlock(\"plasma_current\", size=1, bound=0.1, block_type=\"real\"),\n",
+    "        UncertaintyBlock(\"wall_position\", size=1, bound=0.2, block_type=\"complex\"),\n",
+    "    ]\n",
+    ")\n",
     "\n",
     "# Compute mu upper bound for a sample transfer matrix\n",
     "n = uncertainty.total_size()\n",
@@ -273,10 +275,12 @@
     "for omega in freqs:\n",
     "    # Frequency-dependent transfer matrix (simplified)\n",
     "    s = 1j * omega\n",
-    "    M = np.array([\n",
-    "        [1.0 / (s + 10), 0.5 / (s + 20)],\n",
-    "        [0.3 / (s + 5), 1.0 / (s + 15)],\n",
-    "    ])\n",
+    "    M = np.array(\n",
+    "        [\n",
+    "            [1.0 / (s + 10), 0.5 / (s + 20)],\n",
+    "            [0.3 / (s + 5), 1.0 / (s + 15)],\n",
+    "        ]\n",
+    "    )\n",
     "    delta_struct = uncertainty.build_Delta_structure()\n",
     "    mu = compute_mu_upper_bound(M, delta_struct)\n",
     "    mu_vals.append(mu)\n",
@@ -313,7 +317,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from scpn_control.control.fault_tolerant_control import FDIMonitor, FaultType\n",
+    "from scpn_control.control.fault_tolerant_control import FDIMonitor\n",
     "\n",
     "fdi = FDIMonitor(n_sensors=4, n_actuators=3, threshold_sigma=3.0, n_alert=3)\n",
     "\n",
@@ -376,7 +380,43 @@
    "id": "g2",
    "metadata": {},
    "outputs": [],
-   "source": "from scpn_control.control.shape_controller import (\n    PlasmaShapeController,\n    ShapeTarget,\n    CoilSet,\n)\n\ntarget = ShapeTarget(\n    isoflux_points=[(8.2, 0.0), (7.8, 1.5), (6.5, 3.0),\n                    (5.0, 2.5), (4.5, 0.0), (5.0, -2.5),\n                    (6.5, -3.0), (7.8, -1.5)],\n    gap_points=[(8.5, 0.0, 1.0, 0.0), (4.2, 0.0, -1.0, 0.0)],\n    gap_targets=[0.1, 0.08],\n)\n\ncoils = CoilSet(n_coils=6)\n# kernel=None works — ShapeJacobian uses a mock Jacobian for the demo\nshape_ctrl = PlasmaShapeController(target=target, coil_set=coils, kernel=None)\n\n# Simulate shape correction over several iterations\npsi = np.ones((33, 33)) * 0.5  # mock flux grid\ncoil_currents = np.zeros(6)\n\ncorrections = []\nfor i in range(10):\n    delta_I = shape_ctrl.step(psi, coil_currents)\n    coil_currents = np.clip(coil_currents + delta_I, -coils.max_currents, coils.max_currents)\n    corrections.append(np.linalg.norm(delta_I))\n\nplt.figure(figsize=(8, 4))\nplt.semilogy(corrections, \"bo-\", lw=2)\nplt.xlabel(\"Iteration\")\nplt.ylabel(\"|delta_I| [A]\")\nplt.title(\"Shape controller convergence\")\nplt.grid(True, alpha=0.3)\nplt.show()\n\nprint(f\"Final coil currents: {np.round(coil_currents, 1)}\")"
+   "source": [
+    "from scpn_control.control.shape_controller import (\n",
+    "    PlasmaShapeController,\n",
+    "    ShapeTarget,\n",
+    "    CoilSet,\n",
+    ")\n",
+    "\n",
+    "target = ShapeTarget(\n",
+    "    isoflux_points=[(8.2, 0.0), (7.8, 1.5), (6.5, 3.0), (5.0, 2.5), (4.5, 0.0), (5.0, -2.5), (6.5, -3.0), (7.8, -1.5)],\n",
+    "    gap_points=[(8.5, 0.0, 1.0, 0.0), (4.2, 0.0, -1.0, 0.0)],\n",
+    "    gap_targets=[0.1, 0.08],\n",
+    ")\n",
+    "\n",
+    "coils = CoilSet(n_coils=6)\n",
+    "# kernel=None works — ShapeJacobian uses a mock Jacobian for the demo\n",
+    "shape_ctrl = PlasmaShapeController(target=target, coil_set=coils, kernel=None)\n",
+    "\n",
+    "# Simulate shape correction over several iterations\n",
+    "psi = np.ones((33, 33)) * 0.5  # mock flux grid\n",
+    "coil_currents = np.zeros(6)\n",
+    "\n",
+    "corrections = []\n",
+    "for i in range(10):\n",
+    "    delta_I = shape_ctrl.step(psi, coil_currents)\n",
+    "    coil_currents = np.clip(coil_currents + delta_I, -coils.max_currents, coils.max_currents)\n",
+    "    corrections.append(np.linalg.norm(delta_I))\n",
+    "\n",
+    "plt.figure(figsize=(8, 4))\n",
+    "plt.semilogy(corrections, \"bo-\", lw=2)\n",
+    "plt.xlabel(\"Iteration\")\n",
+    "plt.ylabel(\"|delta_I| [A]\")\n",
+    "plt.title(\"Shape controller convergence\")\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"Final coil currents: {np.round(coil_currents, 1)}\")"
+   ]
   },
   {
    "cell_type": "markdown",