Upload 4 files

tests/test_app_flows.py

@@ -122,8 +122,53 @@ import app
 from quread.engine import QuantumStateVector
 from quread.def_translator import DEFGridConfig, build_def_blockages, to_def_blockages_fragment
 
+DEFAULT_SEVERITY_ARGS = (
+    "linear",
+    "composite_risk",
+    0.45,
+    0.70,
+    67.0,
+    90.0,
+    0.25,
+    0.20,
+    0.15,
+    0.25,
+    0.15,
+)
+
 
 class AppFlowsTest(unittest.TestCase):
+    def test_apply_selected_gate_recovers_from_missing_qc_state(self):
+        qc, last_counts, status = app.apply_selected_gate(None, None, "H", 0, 2)
+
+        self.assertIsNotNone(qc)
+        self.assertEqual(qc.n_qubits, 2)
+        self.assertEqual(len(qc.history), 1)
+        self.assertIsNone(last_counts)
+        self.assertIn("Applied H on q0", status)
+
+    def test_metrics_pipeline_recovers_from_missing_qc_state(self):
+        metrics, meta, qubit_coords, layout_meta = app._current_metrics_and_layout(
+            None,
+            2,
+            2,
+            2,
+            None,
+            "",
+            0.25,
+            0.20,
+            0.15,
+            0.25,
+            0.15,
+            0.45,
+            0.70,
+        )
+
+        self.assertIn("composite_risk", metrics)
+        self.assertEqual(len(metrics["composite_risk"]), 2)
+        self.assertEqual(qubit_coords[0], (0, 0))
+        self.assertEqual(layout_meta["source"], "default")
+
     def test_qubit_count_change_reinitializes_simulator(self):
         qc, last_counts, selected_gate, _target, _control, _cnot_target, status = app._on_qubit_count_change(3)
 
@@ -237,6 +282,34 @@ class AppFlowsTest(unittest.TestCase):
         self.assertTrue(hasattr(fig, "axes"))
         self.assertGreaterEqual(len(fig.axes), 1)
 
+    def test_severity_csv_export_returns_file(self):
+        qc = QuantumStateVector(2)
+        path = app._dl_severity_csv(
+            qc,
+            2,
+            2,
+            2,
+            None,
+            "",
+            0.25,
+            0.20,
+            0.15,
+            0.25,
+            0.15,
+            0.45,
+            0.70,
+            *DEFAULT_SEVERITY_ARGS,
+        )
+        try:
+            text = pathlib.Path(path).read_text(encoding="utf-8")
+            self.assertIn("severity_mode", text.splitlines()[0])
+            self.assertIn("pnr_cost", text.splitlines()[0])
+        finally:
+            try:
+                os.remove(path)
+            except FileNotFoundError:
+                pass
+
     def test_def_export_returns_fragment_file(self):
         qc = QuantumStateVector(2)
         qc.apply_single("H", target=0)
@@ -258,8 +331,7 @@ class AppFlowsTest(unittest.TestCase):
             0.15,
             0.45,
             0.70,
-            "composite_risk",
-            "composite_risk",
+            *DEFAULT_SEVERITY_ARGS,
             "0",
             "0",
             "40",
@@ -298,8 +370,7 @@ class AppFlowsTest(unittest.TestCase):
             0.15,
             0.45,
             0.70,
-            "composite_risk",
-            "composite_risk",
+            *DEFAULT_SEVERITY_ARGS,
             "0",
             "0",
             "40",
@@ -346,8 +417,7 @@ class AppFlowsTest(unittest.TestCase):
             0.15,
             0.45,
             0.70,
-            "composite_risk",
-            "composite_risk",
+            *DEFAULT_SEVERITY_ARGS,
             "0",
             "0",
             "40",
@@ -381,8 +451,7 @@ class AppFlowsTest(unittest.TestCase):
             0.15,
             0.45,
             0.70,
-            "composite_risk",
-            "composite_risk",
+            *DEFAULT_SEVERITY_ARGS,
             "0",
             "0",
             "-1",

tests/test_eda_translator.py

@@ -9,6 +9,7 @@ class EDATranslatorTest(unittest.TestCase):
     def test_mapping_sorted_by_risk_and_contains_fields(self):
         metrics = {
             "composite_risk": np.array([0.25, 0.82, 0.51], dtype=float),
+            "activity_norm": np.array([0.25, 0.82, 0.51], dtype=float),
             "gate_error": np.array([0.01, 0.03, 0.02], dtype=float),
             "readout_error": np.array([0.02, 0.04, 0.03], dtype=float),
             "decoherence_risk": np.array([0.2, 0.7, 0.4], dtype=float),
@@ -20,6 +21,9 @@ class EDATranslatorTest(unittest.TestCase):
         self.assertEqual(rows[0]["tier"], "CRITICAL")
         self.assertIn("timing_derate", rows[0])
         self.assertIn("guardband_mv", rows[0])
+        self.assertIn("severity_score", rows[0])
+        self.assertIn("pnr_cost", rows[0])
+        self.assertIn("density_cap", rows[0])
         self.assertIsNone(rows[0]["layout_row"])
         self.assertIsNone(rows[0]["layout_col"])
         q2 = next(r for r in rows if int(r["qubit"]) == 2)
@@ -29,6 +33,7 @@ class EDATranslatorTest(unittest.TestCase):
     def test_export_generates_nonempty_scripts(self):
         metrics = {
             "composite_risk": np.array([0.2, 0.6], dtype=float),
+            "activity_norm": np.array([0.2, 0.6], dtype=float),
             "gate_error": np.array([0.01, 0.02], dtype=float),
             "readout_error": np.array([0.02, 0.03], dtype=float),
             "decoherence_risk": np.array([0.2, 0.5], dtype=float),
@@ -40,11 +45,14 @@ class EDATranslatorTest(unittest.TestCase):
 
         self.assertIn("Generated by Quread", tcl)
         self.assertIn("quread_q1_risk", tcl)
+        self.assertIn("quread_q1_pnr_cost", tcl)
+        self.assertIn("quread_q1_density_cap", tcl)
         self.assertIn("set quread_q1_row 0", tcl)
         self.assertIn("set quread_q1_col 1", tcl)
         self.assertIn("qureadRiskRows", skill)
         self.assertIn('list("q1"', skill)
-        self.assertIn(' 0 1 "MEDIUM")', skill)
+        self.assertIn(' 0 1 "MEDIUM"', skill)
+        self.assertIn('"composite_risk" "linear"', skill)
 
 
 if __name__ == "__main__":

tests/test_eda_view.py

@@ -15,6 +15,12 @@ class EDAViewParserTest(unittest.TestCase):
                 "set quread_q1_tier CRITICAL",
                 "set quread_q1_timing_derate 1.12",
                 "set quread_q1_guardband_mv 41.0",
+                "set quread_q1_severity_score 0.82",
+                "set quread_q1_severity_percentile 100.0",
+                "set quread_q1_pnr_cost 82.0",
+                "set quread_q1_density_cap 50.8",
+                "set quread_q1_source_metric composite_risk",
+                "set quread_q1_severity_mode linear",
                 "set quread_q1_row 0",
                 "set quread_q1_col 1",
                 "",
@@ -34,12 +40,14 @@ class EDAViewParserTest(unittest.TestCase):
         self.assertEqual(rows[0]["tier"], "CRITICAL")
         self.assertEqual(rows[0]["layout_row"], 0)
         self.assertEqual(rows[0]["layout_col"], 1)
+        self.assertAlmostEqual(rows[0]["severity_score"], 0.82, places=6)
+        self.assertAlmostEqual(rows[0]["pnr_cost"], 82.0, places=6)
 
     def test_parse_cadence_skill_rows(self):
         text = "\n".join(
             [
-                'qureadRiskRows = cons(list("q0" 0.200000 "OK" 1.030000 14.000 1 2 "LOW") qureadRiskRows)',
-                'qureadRiskRows = cons(list("q2" 0.910000 "CRITICAL" 1.140000 55.000 2 1 "HIGH") qureadRiskRows)',
+                'qureadRiskRows = cons(list("q0" 0.200000 "OK" 1.030000 14.000 1 2 "LOW" 0.200000 0.000000 20.000000 88.000000 "composite_risk" "linear") qureadRiskRows)',
+                'qureadRiskRows = cons(list("q2" 0.910000 "CRITICAL" 1.140000 55.000 2 1 "HIGH" 0.950000 100.000000 95.000000 43.000000 "weighted_blend" "pnr_cost") qureadRiskRows)',
             ]
         )
         rows, meta = parse_eda_text(text, "cadence_skill")
@@ -49,6 +57,8 @@ class EDAViewParserTest(unittest.TestCase):
         self.assertEqual(rows[0]["route_priority"], "HIGH")
         self.assertEqual(rows[0]["layout_row"], 2)
         self.assertEqual(rows[0]["layout_col"], 1)
+        self.assertAlmostEqual(rows[0]["pnr_cost"], 95.0, places=6)
+        self.assertEqual(rows[0]["severity_mode"], "pnr_cost")
 
     def test_auto_detect_prefers_recognized_format(self):
         syn_text = "set quread_q0_risk 0.5"

tests/test_severity_mapper.py

@@ -0,0 +1,100 @@
+import unittest
+
+import numpy as np
+
+from quread.severity_mapper import SeverityConfig, SeverityThresholds, SeverityWeights, compute_severity_rows, severity_rows_to_csv
+
+
+class SeverityMapperTest(unittest.TestCase):
+    def _metrics(self):
+        return {
+            "activity_count": np.array([1.0, 4.0, 2.0], dtype=float),
+            "activity_norm": np.array([0.25, 1.0, 0.5], dtype=float),
+            "gate_error": np.array([0.02, 0.75, 0.30], dtype=float),
+            "readout_error": np.array([0.03, 0.40, 0.08], dtype=float),
+            "coherence_health": np.array([0.95, 0.30, 0.70], dtype=float),
+            "decoherence_risk": np.array([0.10, 0.80, 0.35], dtype=float),
+            "fidelity": np.array([0.98, 0.50, 0.90], dtype=float),
+            "state_fidelity": np.array([0.99, 0.55, 0.92], dtype=float),
+            "process_fidelity": np.array([0.98, 0.60, 0.91], dtype=float),
+            "composite_risk": np.array([0.18, 0.86, 0.41], dtype=float),
+        }
+
+    def test_linear_mode_uses_selected_heatmap_metric(self):
+        rows = compute_severity_rows(
+            self._metrics(),
+            cfg=SeverityConfig(mode="linear", source_metric="gate_error"),
+            qubit_coords={0: (0, 0), 1: (0, 1), 2: (1, 0)},
+        )
+        self.assertEqual(rows[0]["qubit"], 1)
+        self.assertEqual(rows[0]["severity_band"], "CRITICAL")
+        self.assertAlmostEqual(rows[0]["severity_score"], 0.75, places=6)
+        self.assertEqual(rows[0]["source_metric"], "gate_error")
+
+    def test_bucket_mode_quantizes_to_three_levels(self):
+        rows = compute_severity_rows(
+            self._metrics(),
+            cfg=SeverityConfig(
+                mode="bucket",
+                source_metric="composite_risk",
+                thresholds=SeverityThresholds(warning=0.4, critical=0.7),
+            ),
+        )
+        values = {int(r["qubit"]): float(r["severity_score"]) for r in rows}
+        self.assertEqual(values[0], 0.0)
+        self.assertEqual(values[1], 1.0)
+        self.assertEqual(values[2], 0.5)
+
+    def test_percentile_mode_uses_current_session_ranking(self):
+        rows = compute_severity_rows(
+            self._metrics(),
+            cfg=SeverityConfig(
+                mode="percentile",
+                source_metric="composite_risk",
+                thresholds=SeverityThresholds(percentile_warning=50.0, percentile_critical=90.0),
+            ),
+        )
+        by_q = {int(r["qubit"]): r for r in rows}
+        self.assertEqual(by_q[1]["severity_band"], "CRITICAL")
+        self.assertEqual(by_q[1]["severity_rank"], 1)
+        self.assertGreater(by_q[1]["severity_percentile"], by_q[2]["severity_percentile"])
+
+    def test_weighted_mode_uses_separate_weight_model(self):
+        rows = compute_severity_rows(
+            self._metrics(),
+            cfg=SeverityConfig(
+                mode="weighted",
+                weights=SeverityWeights(activity=0.0, gate_error=1.0, readout_error=0.0, decoherence=0.0, fidelity=0.0),
+            ),
+        )
+        self.assertEqual(rows[0]["qubit"], 1)
+        self.assertEqual(rows[0]["source_metric"], "weighted_blend")
+        self.assertAlmostEqual(rows[0]["severity_score"], 0.75, places=6)
+
+    def test_pnr_cost_mode_emits_richer_outputs(self):
+        rows = compute_severity_rows(
+            self._metrics(),
+            cfg=SeverityConfig(mode="pnr_cost"),
+        )
+        top = rows[0]
+        self.assertEqual(top["severity_band"], "CRITICAL")
+        self.assertGreater(top["pnr_cost"], 0.0)
+        self.assertGreater(top["timing_derate"], 1.0)
+        self.assertLess(top["density_cap"], 100.0)
+        self.assertIn(top["route_priority"], {"LOW", "MEDIUM", "HIGH"})
+
+    def test_severity_rows_to_csv_contains_headers(self):
+        csv_text = severity_rows_to_csv(
+            compute_severity_rows(
+                self._metrics(),
+                cfg=SeverityConfig(mode="linear", source_metric="composite_risk"),
+                qubit_coords={0: (0, 0), 1: (0, 1), 2: (1, 0)},
+            )
+        )
+        self.assertIn("severity_mode", csv_text.splitlines()[0])
+        self.assertIn("pnr_cost", csv_text.splitlines()[0])
+        self.assertIn("\n1,0,1,", csv_text)
+
+
+if __name__ == "__main__":
+    unittest.main()