Upload eda_view.py

quread/eda_view.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Tuple
+
+
+_FLOAT_RE = r"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?"
+
+_SYN_RE = {
+    "risk": re.compile(rf"^set\s+quread_q(\d+)_risk\s+({_FLOAT_RE})\s*$"),
+    "tier": re.compile(r"^set\s+quread_q(\d+)_tier\s+([A-Za-z_]+)\s*$"),
+    "timing_derate": re.compile(rf"^set\s+quread_q(\d+)_timing_derate\s+({_FLOAT_RE})\s*$"),
+    "guardband_mv": re.compile(rf"^set\s+quread_q(\d+)_guardband_mv\s+({_FLOAT_RE})\s*$"),
+    "row": re.compile(r"^set\s+quread_q(\d+)_row\s+(-?\d+)\s*$"),
+    "col": re.compile(r"^set\s+quread_q(\d+)_col\s+(-?\d+)\s*$"),
+    "comment_route": re.compile(r"^#\s*q(\d+):.*\broute=([A-Za-z_]+)\b.*$"),
+}
+
+_CAD_ROW_RE = re.compile(
+    rf'^qureadRiskRows\s*=\s*cons\(list\("q(\d+)"\s+({_FLOAT_RE})\s+"([^"]+)"\s+({_FLOAT_RE})\s+({_FLOAT_RE})\s+(-?\d+)\s+(-?\d+)\s+"([^"]+)"\)\s+qureadRiskRows\)\s*$'
+)
+
+
+def _default_row(q: int) -> Dict[str, Any]:
+    return {
+        "qubit": int(q),
+        "tier": "UNKNOWN",
+        "composite_risk": 0.0,
+        "timing_derate": 1.0,
+        "guardband_mv": 0.0,
+        "route_priority": "UNKNOWN",
+        "layout_row": None,
+        "layout_col": None,
+    }
+
+
+def _finalize_rows(rows_by_q: Dict[int, Dict[str, Any]]) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    for q in sorted(rows_by_q.keys()):
+        row = dict(rows_by_q[q])
+        rr = row.get("layout_row")
+        cc = row.get("layout_col")
+        if isinstance(rr, int) and rr < 0:
+            row["layout_row"] = None
+        if isinstance(cc, int) and cc < 0:
+            row["layout_col"] = None
+        rows.append(row)
+    rows.sort(key=lambda r: float(r.get("composite_risk", 0.0)), reverse=True)
+    return rows
+
+
+def detect_eda_format(text: str) -> str:
+    raw = str(text or "")
+    syn_hits = raw.count("set quread_q")
+    cad_hits = raw.count('qureadRiskRows = cons(list("q')
+    if syn_hits == 0 and cad_hits == 0:
+        return "unknown"
+    if syn_hits >= cad_hits:
+        return "synopsys_tcl"
+    return "cadence_skill"
+
+
+def parse_synopsys_tcl(text: str) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+    rows_by_q: Dict[int, Dict[str, Any]] = {}
+    parsed = 0
+
+    for raw_line in str(text or "").splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+
+        m = _SYN_RE["risk"].match(line)
+        if m:
+            q = int(m.group(1))
+            rows_by_q.setdefault(q, _default_row(q))["composite_risk"] = float(m.group(2))
+            parsed += 1
+            continue
+
+        m = _SYN_RE["tier"].match(line)
+        if m:
+            q = int(m.group(1))
+            rows_by_q.setdefault(q, _default_row(q))["tier"] = str(m.group(2)).upper()
+            parsed += 1
+            continue
+
+        m = _SYN_RE["timing_derate"].match(line)
+        if m:
+            q = int(m.group(1))
+            rows_by_q.setdefault(q, _default_row(q))["timing_derate"] = float(m.group(2))
+            parsed += 1
+            continue
+
+        m = _SYN_RE["guardband_mv"].match(line)
+        if m:
+            q = int(m.group(1))
+            rows_by_q.setdefault(q, _default_row(q))["guardband_mv"] = float(m.group(2))
+            parsed += 1
+            continue
+
+        m = _SYN_RE["row"].match(line)
+        if m:
+            q = int(m.group(1))
+            rows_by_q.setdefault(q, _default_row(q))["layout_row"] = int(m.group(2))
+            parsed += 1
+            continue
+
+        m = _SYN_RE["col"].match(line)
+        if m:
+            q = int(m.group(1))
+            rows_by_q.setdefault(q, _default_row(q))["layout_col"] = int(m.group(2))
+            parsed += 1
+            continue
+
+        m = _SYN_RE["comment_route"].match(line)
+        if m:
+            q = int(m.group(1))
+            rows_by_q.setdefault(q, _default_row(q))["route_priority"] = str(m.group(2)).upper()
+            parsed += 1
+            continue
+
+    rows = _finalize_rows(rows_by_q)
+    meta = {
+        "format": "synopsys_tcl",
+        "parsed_rows": len(rows),
+        "matched_fields": int(parsed),
+    }
+    return rows, meta
+
+
+def parse_cadence_skill(text: str) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+    rows_by_q: Dict[int, Dict[str, Any]] = {}
+    matched_rows = 0
+    for raw_line in str(text or "").splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        m = _CAD_ROW_RE.match(line)
+        if not m:
+            continue
+        q = int(m.group(1))
+        row = rows_by_q.setdefault(q, _default_row(q))
+        row["qubit"] = q
+        row["composite_risk"] = float(m.group(2))
+        row["tier"] = str(m.group(3)).upper()
+        row["timing_derate"] = float(m.group(4))
+        row["guardband_mv"] = float(m.group(5))
+        row["layout_row"] = int(m.group(6))
+        row["layout_col"] = int(m.group(7))
+        row["route_priority"] = str(m.group(8)).upper()
+        matched_rows += 1
+
+    rows = _finalize_rows(rows_by_q)
+    meta = {
+        "format": "cadence_skill",
+        "parsed_rows": len(rows),
+        "matched_rows": int(matched_rows),
+    }
+    return rows, meta
+
+
+def parse_eda_text(text: str, format_hint: str = "auto") -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+    hint = str(format_hint or "auto").strip().lower()
+    if hint == "auto":
+        fmt = detect_eda_format(text)
+        if fmt == "synopsys_tcl":
+            rows, meta = parse_synopsys_tcl(text)
+            if rows:
+                return rows, meta
+        if fmt == "cadence_skill":
+            rows, meta = parse_cadence_skill(text)
+            if rows:
+                return rows, meta
+        # fallback trial, then pick richer parse
+        syn_rows, syn_meta = parse_synopsys_tcl(text)
+        cad_rows, cad_meta = parse_cadence_skill(text)
+        if len(syn_rows) >= len(cad_rows) and syn_rows:
+            return syn_rows, syn_meta
+        if cad_rows:
+            return cad_rows, cad_meta
+        raise ValueError("No recognizable EDA reliability rows found in input.")
+
+    if hint in ("synopsys", "synopsys_tcl", "tcl"):
+        rows, meta = parse_synopsys_tcl(text)
+        if not rows:
+            raise ValueError("No Synopsys TCL risk rows found in input.")
+        return rows, meta
+
+    if hint in ("cadence", "cadence_skill", "skill", "il"):
+        rows, meta = parse_cadence_skill(text)
+        if not rows:
+            raise ValueError("No Cadence SKILL risk rows found in input.")
+        return rows, meta
+
+    raise ValueError(f"Unsupported format hint: {format_hint}")