Upload 10 files

tests/test_app_flows.py

@@ -0,0 +1,218 @@
+import os
+import pathlib
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+
+def _install_gradio_stub() -> None:
+    if "gradio" in sys.modules:
+        return
+
+    module = types.ModuleType("gradio")
+
+    class _Event:
+        def then(self, *args, **kwargs):
+            return self
+
+    class _Component:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
+
+        def click(self, *args, **kwargs):
+            return _Event()
+
+        def change(self, *args, **kwargs):
+            return _Event()
+
+    class _Context:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+    class _Blocks(_Context):
+        def load(self, *args, **kwargs):
+            return _Event()
+
+        def launch(self, *args, **kwargs):
+            return None
+
+    class _Themes:
+        class Soft:
+            def __init__(self, *args, **kwargs):
+                self.args = args
+                self.kwargs = kwargs
+
+    module.themes = _Themes()
+    module.Blocks = _Blocks
+    module.Row = _Context
+    module.Column = _Context
+    module.Group = _Context
+    module.Tabs = _Context
+    module.Tab = _Context
+    module.Accordion = _Context
+
+    module.State = _Component
+    module.Markdown = _Component
+    module.Slider = _Component
+    module.Button = _Component
+    module.Dropdown = _Component
+    module.Checkbox = _Component
+    module.HTML = _Component
+    module.Code = _Component
+    module.Dataframe = _Component
+    module.Textbox = _Component
+    module.DownloadButton = _Component
+    module.Plot = _Component
+
+    sys.modules["gradio"] = module
+
+
+def _install_openai_stub() -> None:
+    if "openai" in sys.modules:
+        return
+
+    module = types.ModuleType("openai")
+
+    class _Completions:
+        def create(self, *args, **kwargs):
+            raise RuntimeError("OpenAI call is stubbed in tests.")
+
+    class _Chat:
+        def __init__(self):
+            self.completions = _Completions()
+
+    class OpenAI:
+        def __init__(self, *args, **kwargs):
+            self.chat = _Chat()
+
+    module.OpenAI = OpenAI
+    sys.modules["openai"] = module
+
+
+def _install_export_pdf_stub() -> None:
+    if "quread.export_pdf" in sys.modules:
+        return
+
+    module = types.ModuleType("quread.export_pdf")
+
+    def md_to_pdf(markdown_text: str, output_path: str):
+        pathlib.Path(output_path).write_text(markdown_text or "", encoding="utf-8")
+
+    module.md_to_pdf = md_to_pdf
+    sys.modules["quread.export_pdf"] = module
+
+
+_install_gradio_stub()
+_install_openai_stub()
+_install_export_pdf_stub()
+
+import app
+from quread.engine import QuantumStateVector
+
+
+class AppFlowsTest(unittest.TestCase):
+    def test_qubit_count_change_reinitializes_simulator(self):
+        qc, last_counts, selected_gate, _target, _control, _cnot_target, status = app._on_qubit_count_change(3)
+
+        self.assertEqual(qc.n_qubits, 3)
+        self.assertEqual(qc.history, [])
+        self.assertIsNone(last_counts)
+        self.assertEqual(selected_gate, "H")
+        self.assertIn("Reinitialized simulator with 3 qubits", status)
+
+    def test_write_tmp_generates_unique_paths(self):
+        p1 = app._write_tmp("circuit.qasm", "OPENQASM 2.0;")
+        p2 = app._write_tmp("circuit.qasm", "OPENQASM 2.0;")
+        try:
+            self.assertNotEqual(p1, p2)
+            self.assertTrue(pathlib.Path(p1).exists())
+            self.assertTrue(pathlib.Path(p2).exists())
+            self.assertEqual(pathlib.Path(p1).read_text(encoding="utf-8"), "OPENQASM 2.0;")
+            self.assertEqual(pathlib.Path(p2).read_text(encoding="utf-8"), "OPENQASM 2.0;")
+        finally:
+            for path in (p1, p2):
+                try:
+                    os.remove(path)
+                except FileNotFoundError:
+                    pass
+
+    def test_explain_reuse_preserves_previous_markdown(self):
+        qc = QuantumStateVector(2)
+        last_hash = app._circuit_hash(qc.history)
+
+        shown, returned_hash, stored_md = app.explain_llm(
+            qc=qc,
+            n_qubits=2,
+            shots=1024,
+            last_hash=last_hash,
+            previous_explanation="previous explanation",
+        )
+
+        self.assertEqual(returned_hash, last_hash)
+        self.assertEqual(stored_md, "previous explanation")
+        self.assertIn("Reusing previous explanation", shown)
+
+    def test_explain_failure_preserves_previous_markdown(self):
+        qc = QuantumStateVector(2)
+        qc.apply_single("H", target=0)
+
+        with patch.object(app, "explain_with_gpt4o", side_effect=RuntimeError("boom")):
+            shown, returned_hash, stored_md = app.explain_llm(
+                qc=qc,
+                n_qubits=2,
+                shots=1024,
+                last_hash="",
+                previous_explanation="previous explanation",
+            )
+
+        self.assertEqual(returned_hash, "")
+        self.assertEqual(stored_md, "previous explanation")
+        self.assertIn("Explanation request failed", shown)
+        self.assertIn("Showing previous explanation", shown)
+
+    def test_hotspot_rows_sorted_descending(self):
+        metrics = {
+            "composite_risk": np.array([0.22, 0.91, 0.45], dtype=float),
+            "hotspot_level": np.array([0, 2, 1], dtype=float),
+            "activity_count": np.array([1.0, 4.0, 2.0], dtype=float),
+            "gate_error": np.array([0.01, 0.04, 0.02], dtype=float),
+            "readout_error": np.array([0.02, 0.05, 0.03], dtype=float),
+            "state_fidelity": np.array([0.98, 0.82, 0.91], dtype=float),
+            "process_fidelity": np.array([0.97, 0.79, 0.9], dtype=float),
+            "coherence_health": np.array([0.8, 0.5, 0.7], dtype=float),
+            "decoherence_risk": np.array([0.2, 0.6, 0.3], dtype=float),
+            "fidelity": np.array([0.99, 0.95, 0.97], dtype=float),
+        }
+        rows = app._hotspot_rows(metrics, n_qubits=3, top_k=2)
+        self.assertEqual(len(rows), 2)
+        self.assertEqual(rows[0][0], 1)
+        self.assertEqual(rows[0][1], "critical")
+        self.assertGreaterEqual(rows[0][2], rows[1][2])
+
+    def test_ideal_vs_noisy_plot_returns_figure(self):
+        qc = QuantumStateVector(2)
+        qc.apply_single("H", target=0)
+        fig = app._ideal_vs_noisy_plot(
+            qc=qc,
+            shots=64,
+            calibration_text='{"qubits":{"0":{"readout_error":0.1},"1":{"readout_error":0.1}}}',
+            readout_scale=1.0,
+            depolarizing_prob=0.1,
+        )
+        self.assertTrue(hasattr(fig, "axes"))
+        self.assertGreaterEqual(len(fig.axes), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_exporters.py

@@ -0,0 +1,39 @@
+import unittest
+
+from quread.engine import QuantumStateVector
+from quread.exporters import to_cirq, to_openqasm2, to_qiskit
+
+
+class ExportersTest(unittest.TestCase):
+    def test_all_palette_gates_export_cleanly(self):
+        qc = QuantumStateVector(2)
+        gates = ["H", "T†", "S†", "√X", "√Z", "RX(π)", "RY(π/2)", "RZ(π/2)", "I†", "X", "Y", "Z", "S", "T"]
+        for gate in gates:
+            qc.apply_single(gate, target=0)
+        qc.apply_cnot(0, 1)
+
+        qasm = to_openqasm2(qc.history, 2)
+        qiskit_src = to_qiskit(qc.history, 2)
+        cirq_src = to_cirq(qc.history, 2)
+
+        self.assertIn("tdg q[0];", qasm)
+        self.assertIn("sdg q[0];", qasm)
+        self.assertIn("rx(1.5707963267949) q[0];", qasm)
+        self.assertNotIn("π", qasm)
+
+        self.assertIn("qc.tdg(0)", qiskit_src)
+        self.assertIn("qc.sdg(0)", qiskit_src)
+        self.assertIn("qc.sx(0)", qiskit_src)
+        self.assertIn("qc.rx(3.14159265358979, 0)", qiskit_src)
+        self.assertNotIn("qc.rx(π)", qiskit_src)
+
+        self.assertIn("(cirq.T**-1).on(q[0])", cirq_src)
+        self.assertIn("(cirq.S**-1).on(q[0])", cirq_src)
+        self.assertIn("(cirq.X**0.5).on(q[0])", cirq_src)
+
+        compile(qiskit_src, "<qiskit_export>", "exec")
+        compile(cirq_src, "<cirq_export>", "exec")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_heatmap.py

@@ -0,0 +1,33 @@
+import unittest
+
+import matplotlib
+
+matplotlib.use("Agg")
+
+from quread.heatmap import HeatmapConfig, make_activity_heatmap
+
+
+class HeatmapTest(unittest.TestCase):
+    def test_malformed_rows_are_skipped_without_crashing(self):
+        csv_text = "\n".join(
+            [
+                "step,gate,target,control,theta",
+                "0,H,0,,",
+                "1,CNOT,1,0,",
+                "2,H,not_an_int,,",
+                "3,,1,,",
+            ]
+        )
+
+        fig = make_activity_heatmap(csv_text, n_qubits=2, cfg=HeatmapConfig(rows=2, cols=2))
+        ax = fig.axes[0]
+        grid = ax.images[0].get_array()
+        labels = [t.get_text() for t in ax.texts]
+
+        self.assertEqual(float(grid[0, 0]), 2.0)  # q0: H + CNOT(control)
+        self.assertEqual(float(grid[0, 1]), 1.0)  # q1: CNOT(target)
+        self.assertIn("Skipped 2 malformed CSV row(s)", labels)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_metrics.py

@@ -0,0 +1,87 @@
+import unittest
+
+from quread.metrics import (
+    compute_metrics_from_csv,
+    to_metrics_csv,
+    MetricWeights,
+    MetricThresholds,
+    clamp_thresholds,
+)
+
+
+class MetricsPipelineTest(unittest.TestCase):
+    def test_compute_metrics_and_export_csv(self):
+        csv_text = "\n".join(
+            [
+                "step,gate,target,control,theta",
+                "0,H,0,,",
+                "1,CNOT,1,0,",
+                "2,X,1,,",
+            ]
+        )
+        calibration = (
+            '{"qubits":{"0":{"gate_error":0.01,"readout_error":0.02,"t1_us":90,"t2_us":70,"fidelity":0.992},'
+            '"1":{"gate_error":0.03,"readout_error":0.04,"t1_us":55,"t2_us":45,"fidelity":0.981}}}'
+        )
+
+        metrics, meta = compute_metrics_from_csv(csv_text, 2, calibration_json=calibration)
+
+        self.assertEqual(meta["skipped_rows"], 0)
+        self.assertIn("fidelity_backend", meta)
+        self.assertEqual(metrics["activity_count"].shape[0], 2)
+        self.assertGreaterEqual(float(metrics["activity_norm"][0]), 0.0)
+        self.assertLessEqual(float(metrics["activity_norm"][0]), 1.0)
+        self.assertGreaterEqual(float(metrics["composite_risk"][1]), 0.0)
+        self.assertLessEqual(float(metrics["composite_risk"][1]), 1.0)
+        self.assertGreaterEqual(float(metrics["state_fidelity"][0]), 0.0)
+        self.assertLessEqual(float(metrics["state_fidelity"][0]), 1.0)
+        self.assertGreaterEqual(float(metrics["process_fidelity"][0]), 0.0)
+        self.assertLessEqual(float(metrics["process_fidelity"][0]), 1.0)
+
+        csv_out = to_metrics_csv(metrics)
+        self.assertIn("qubit,activity_count,activity_norm,gate_error", csv_out)
+        self.assertIn("coherence_health", csv_out.splitlines()[0])
+        self.assertIn("state_fidelity", csv_out.splitlines()[0])
+        self.assertIn("process_fidelity", csv_out.splitlines()[0])
+        self.assertIn("\n0,", csv_out)
+        self.assertIn("\n1,", csv_out)
+
+    def test_invalid_calibration_json_falls_back_to_defaults(self):
+        csv_text = "step,gate,target,control,theta\n0,H,0,,\n"
+        metrics, meta = compute_metrics_from_csv(csv_text, 1, calibration_json="{bad json")
+
+        self.assertIn("using defaults", str(meta.get("calibration_note", "")).lower())
+        self.assertEqual(metrics["activity_count"].shape[0], 1)
+
+    def test_threshold_clamping_orders_warning_and_critical(self):
+        clamped = clamp_thresholds(MetricThresholds(warning=0.8, critical=0.5))
+        self.assertEqual(clamped.warning, 0.8)
+        self.assertEqual(clamped.critical, 0.8)
+
+    def test_custom_weights_affect_composite_risk(self):
+        csv_text = "\n".join(
+            [
+                "step,gate,target,control,theta",
+                "0,H,0,,",
+                "1,H,0,,",
+                "2,H,0,,",
+            ]
+        )
+        calibration = (
+            '{"qubits":{"0":{"gate_error":0.01,"readout_error":0.01,"t1_us":120,"t2_us":100,"fidelity":0.995},'
+            '"1":{"gate_error":0.02,"readout_error":0.02,"t1_us":120,"t2_us":100,"fidelity":0.995}}}'
+        )
+        # Heavy activity weighting should make q0 risk noticeably higher.
+        metrics, _ = compute_metrics_from_csv(
+            csv_text,
+            2,
+            calibration_json=calibration,
+            weights=MetricWeights(activity=0.9, gate_error=0.025, readout_error=0.025, decoherence=0.025, fidelity=0.025),
+            thresholds=MetricThresholds(warning=0.2, critical=0.6),
+        )
+        self.assertGreater(float(metrics["composite_risk"][0]), float(metrics["composite_risk"][1]))
+        self.assertEqual(int(metrics["hotspot_level"][0]), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_noise_model.py

@@ -0,0 +1,43 @@
+import unittest
+
+import numpy as np
+
+from quread.noise_model import sample_noisy_counts
+
+
+class NoiseModelTest(unittest.TestCase):
+    def test_readout_flip_probability_one_flips_all_bits(self):
+        state = np.zeros((4,), dtype=complex)
+        state[0] = 1.0 + 0j  # |00>
+        calibration = '{"qubits":{"0":{"readout_error":1.0},"1":{"readout_error":1.0}}}'
+
+        counts = sample_noisy_counts(
+            state,
+            n_qubits=2,
+            shots=32,
+            calibration_json=calibration,
+            readout_scale=1.0,
+            depolarizing_prob=0.0,
+            seed=7,
+        )
+        self.assertEqual(counts, {"11": 32})
+
+    def test_depolarizing_only_creates_multiple_outcomes(self):
+        state = np.zeros((4,), dtype=complex)
+        state[0] = 1.0 + 0j  # |00>
+
+        counts = sample_noisy_counts(
+            state,
+            n_qubits=2,
+            shots=128,
+            calibration_json="",
+            readout_scale=0.0,
+            depolarizing_prob=0.4,
+            seed=123,
+        )
+        self.assertGreater(len(counts), 1)
+        self.assertEqual(sum(counts.values()), 128)
+
+
+if __name__ == "__main__":
+    unittest.main()