| """Streamlit dashboard for cross-engine migration comparison."""
|
| from __future__ import annotations
|
|
|
| import html
|
| import json
|
| import os
|
| import sys
|
| from pathlib import Path
|
| from typing import Dict, List, Mapping
|
|
|
| import pandas as pd
|
| import plotly.express as px
|
| import plotly.graph_objects as go
|
| import streamlit as st
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parent.parent
|
| if str(PROJECT_ROOT) not in sys.path:
|
| sys.path.insert(0, str(PROJECT_ROOT))
|
|
|
| from rulepacks.registry import DEFAULT_PROFILE, SUPPORTED_PROFILES
|
| from validation.engine_comparison import COMPARISON_PATH, run_engine_comparison
|
|
|
| DEFAULT_SOURCE_JSONL = PROJECT_ROOT / "openfoodfacts-products.jsonl"
|
| ENGINE_COLORS = {
|
| "python": "#2563eb",
|
| "dbt": "#f97316",
|
| "soda": "#10b981",
|
| }
|
|
|
|
|
| def load_report() -> dict:
|
| if not COMPARISON_PATH.exists():
|
| return {}
|
| with COMPARISON_PATH.open("r", encoding="utf-8") as handle:
|
| return json.load(handle)
|
|
|
|
|
| def _inject_theme() -> None:
|
| st.markdown(
|
| """
|
| <style>
|
| @import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap');
|
| @import url('https://fonts.googleapis.com/css2?family=Material+Symbols+Rounded:opsz,wght,FILL,GRAD@20..48,400,0,0');
|
| html, body, [class*="st-"], [class*="css"] {
|
| font-family: "Space Grotesk", sans-serif;
|
| }
|
| [class^="material-symbols"], [class*=" material-symbols"] {
|
| font-family: "Material Symbols Rounded" !important;
|
| font-weight: normal;
|
| font-style: normal;
|
| font-size: 1rem;
|
| line-height: 1;
|
| letter-spacing: normal;
|
| text-transform: none;
|
| display: inline-block;
|
| white-space: nowrap;
|
| word-wrap: normal;
|
| direction: ltr;
|
| -webkit-font-smoothing: antialiased;
|
| }
|
| .block-container {
|
| max-width: 1260px;
|
| padding-top: 1.15rem;
|
| padding-bottom: 2rem;
|
| }
|
| [data-testid="stMetric"] {
|
| background: linear-gradient(120deg, #f8fafc 0%, #ecfeff 100%);
|
| border: 1px solid #dbeafe;
|
| border-radius: 14px;
|
| padding: 0.6rem 0.8rem;
|
| min-height: 118px;
|
| }
|
| [data-testid="stMetricLabel"] > div {
|
| white-space: normal !important;
|
| line-height: 1.15;
|
| }
|
| [data-testid="stMetricValue"] > div {
|
| line-height: 1.15;
|
| }
|
| .stat-chip {
|
| border-radius: 16px;
|
| border: 1px solid #dbeafe;
|
| background: linear-gradient(135deg, #f8fafc 0%, #ecfeff 100%);
|
| padding: 0.8rem 0.95rem;
|
| min-height: 112px;
|
| display: flex;
|
| flex-direction: column;
|
| justify-content: space-between;
|
| overflow: hidden;
|
| box-shadow: 0 4px 12px rgba(15, 23, 42, 0.06);
|
| }
|
| .stat-chip .label {
|
| color: #475569;
|
| font-size: 0.76rem;
|
| line-height: 1.1rem;
|
| font-weight: 600;
|
| text-transform: uppercase;
|
| letter-spacing: 0.04em;
|
| word-break: normal;
|
| overflow-wrap: break-word;
|
| }
|
| .stat-chip .value {
|
| color: #0f172a;
|
| font-size: 1.28rem;
|
| font-weight: 700;
|
| line-height: 1.4rem;
|
| margin-top: 0.5rem;
|
| white-space: normal;
|
| word-break: break-word;
|
| }
|
| .hero {
|
| border-radius: 16px;
|
| border: 1px solid #cbd5e1;
|
| background: radial-gradient(circle at 10% 20%, #f0fdfa 0%, #eff6ff 45%, #fff7ed 100%);
|
| padding: 1rem 1.2rem;
|
| margin-bottom: 1.1rem;
|
| }
|
| .hero h1 {
|
| margin: 0;
|
| color: #0b1324;
|
| font-size: 1.38rem;
|
| letter-spacing: -0.01em;
|
| }
|
| .hero p {
|
| margin: 0.3rem 0 0 0;
|
| color: #334155;
|
| font-size: 0.95rem;
|
| }
|
| .explain-chip {
|
| border-radius: 14px;
|
| border: 1px solid #bfdbfe;
|
| background: linear-gradient(135deg, #eff6ff 0%, #f0f9ff 100%);
|
| padding: 0.8rem 0.95rem;
|
| margin: 0.6rem 0 0.9rem 0;
|
| box-shadow: 0 4px 12px rgba(15, 23, 42, 0.05);
|
| }
|
| .explain-chip .title {
|
| color: #1e3a8a;
|
| font-size: 0.88rem;
|
| line-height: 1.2rem;
|
| font-weight: 700;
|
| margin-bottom: 0.35rem;
|
| text-transform: uppercase;
|
| letter-spacing: 0.03em;
|
| }
|
| .explain-chip ul {
|
| margin: 0.1rem 0 0 1rem;
|
| padding: 0;
|
| }
|
| .explain-chip li {
|
| color: #1e293b;
|
| font-size: 0.92rem;
|
| line-height: 1.35rem;
|
| margin: 0.2rem 0;
|
| }
|
| [data-testid="stExpander"] > details > summary {
|
| display: flex;
|
| align-items: center;
|
| gap: 0.5rem;
|
| line-height: 1.25;
|
| }
|
| [data-testid="stExpander"] > details > summary p {
|
| margin: 0 !important;
|
| line-height: 1.25 !important;
|
| }
|
| [data-testid="stExpander"] > details > summary svg {
|
| flex-shrink: 0;
|
| margin-top: 0 !important;
|
| }
|
| </style>
|
| """,
|
| unsafe_allow_html=True,
|
| )
|
|
|
|
|
| def _to_pct(value: object) -> float:
|
| try:
|
| return round(float(value) * 100, 2)
|
| except (TypeError, ValueError):
|
| return 0.0
|
|
|
|
|
| def _render_stat_chip(label: str, value: object) -> None:
|
| st.markdown(
|
| (
|
| "<div class='stat-chip'>"
|
| f"<div class='label'>{label}</div>"
|
| f"<div class='value'>{value}</div>"
|
| "</div>"
|
| ),
|
| unsafe_allow_html=True,
|
| )
|
|
|
|
|
| def _render_explain_chip(title: str, lines: List[str]) -> None:
|
| safe_items = "".join(f"<li>{html.escape(line)}</li>" for line in lines if line)
|
| st.markdown(
|
| (
|
| "<div class='explain-chip'>"
|
| f"<div class='title'>{html.escape(title)}</div>"
|
| f"<ul>{safe_items}</ul>"
|
| "</div>"
|
| ),
|
| unsafe_allow_html=True,
|
| )
|
|
|
|
|
| def _engine_summary_frame(per_engine_summary: Mapping[str, Mapping[str, object]]) -> pd.DataFrame:
|
| rows: List[Dict[str, object]] = []
|
| for engine in ("python", "dbt", "soda"):
|
| summary = per_engine_summary.get(engine, {})
|
| rows.append(
|
| {
|
| "engine": engine.upper(),
|
| "rules": int(summary.get("rules", 0)),
|
| "passed": int(summary.get("passed", 0)),
|
| "avg_overall_confidence_pct": _to_pct(summary.get("avg_overall_confidence", 0.0)),
|
| "avg_effective_confidence_pct": _to_pct(summary.get("avg_effective_confidence", 0.0)),
|
| "avg_parity_ci_low_pct": _to_pct(summary.get("avg_parity_ci_lower", 0.0)),
|
| "avg_equivalence_rate_pct": _to_pct(summary.get("avg_equivalence_rate", 0.0)),
|
| "avg_mutation_score_pct": _to_pct(summary.get("avg_mutation_score", 0.0)),
|
| "fallback_rules": int(summary.get("fallback_rules", 0)),
|
| "real_llm_rules": int(summary.get("real_llm_rules", 0)) if engine == "python" else None,
|
| "real_llm_rate_pct": _to_pct(summary.get("real_llm_rate", 0.0)) if engine == "python" else None,
|
| "repairs_applied": int(summary.get("repairs_applied", 0)) if engine == "python" else None,
|
| }
|
| )
|
| return pd.DataFrame(rows)
|
|
|
|
|
| def _rule_frame(rule_comparison: List[Mapping[str, object]]) -> pd.DataFrame:
|
| rows: List[Dict[str, object]] = []
|
| for item in rule_comparison:
|
| engines = item.get("engines", {})
|
| py = engines.get("python", {})
|
| dbt = engines.get("dbt", {})
|
| soda = engines.get("soda", {})
|
| best_engine = str(item.get("best_engine", "python"))
|
|
|
| effective_confidences = {
|
| "python": float(py.get("effective_confidence", py.get("overall_confidence", 0.0))),
|
| "dbt": float(dbt.get("effective_confidence", dbt.get("overall_confidence", 0.0))),
|
| "soda": float(soda.get("effective_confidence", soda.get("overall_confidence", 0.0))),
|
| }
|
| sorted_conf = sorted(effective_confidences.values(), reverse=True)
|
| margin = sorted_conf[0] - sorted_conf[1] if len(sorted_conf) > 1 else sorted_conf[0]
|
| decision_scores = {
|
| "python": float(py.get("decision_score", effective_confidences["python"])),
|
| "dbt": float(dbt.get("decision_score", effective_confidences["dbt"])),
|
| "soda": float(soda.get("decision_score", effective_confidences["soda"])),
|
| }
|
| sorted_scores = sorted(decision_scores.values(), reverse=True)
|
| score_margin = sorted_scores[0] - sorted_scores[1] if len(sorted_scores) > 1 else sorted_scores[0]
|
|
|
| rows.append(
|
| {
|
| "rule_name": item.get("rule_name", ""),
|
| "severity": item.get("severity", ""),
|
| "condition": item.get("condition", ""),
|
| "condition_type": item.get("condition_type", "unknown"),
|
| "complexity": item.get("complexity", "unknown"),
|
| "declarative_friendly": bool(item.get("declarative_friendly", False)),
|
| "jurisdiction": str(item.get("jurisdiction", "global")),
|
| "regulatory_type": str(item.get("regulatory_type", "")),
|
| "legal_citation": str(item.get("legal_citation", "")),
|
| "review_status": str(item.get("review_status", "")),
|
| "products_tested": int(item.get("products_tested", 0)),
|
| "best_engine": best_engine,
|
| "best_effective_pct": _to_pct(effective_confidences.get(best_engine, 0.0)),
|
| "effective_margin_pct": round(margin * 100, 2),
|
| "best_decision_score": round(decision_scores.get(best_engine, 0.0), 4),
|
| "decision_margin": round(score_margin, 4),
|
| "python_status": py.get("status", "n/a"),
|
| "dbt_status": dbt.get("status", "n/a"),
|
| "soda_status": soda.get("status", "n/a"),
|
| "python_effective_pct": _to_pct(py.get("effective_confidence", py.get("overall_confidence", 0.0))),
|
| "dbt_effective_pct": _to_pct(dbt.get("effective_confidence", dbt.get("overall_confidence", 0.0))),
|
| "soda_effective_pct": _to_pct(soda.get("effective_confidence", soda.get("overall_confidence", 0.0))),
|
| "python_decision_score": round(decision_scores["python"], 4),
|
| "dbt_decision_score": round(decision_scores["dbt"], 4),
|
| "soda_decision_score": round(decision_scores["soda"], 4),
|
| "python_overall_pct": _to_pct(py.get("overall_confidence", 0.0)),
|
| "dbt_overall_pct": _to_pct(dbt.get("overall_confidence", 0.0)),
|
| "soda_overall_pct": _to_pct(soda.get("overall_confidence", 0.0)),
|
| "python_equivalence_pct": _to_pct(py.get("equivalence_match_rate", 1.0)),
|
| "python_mutation_pct": _to_pct(py.get("mutation_score", 1.0)),
|
| "python_verification_pct": _to_pct(py.get("verification_score", 1.0)),
|
| "python_repair_applied": bool(py.get("counterexample_repair_applied", False)),
|
| "python_mismatches": int(py.get("mismatches", 0)),
|
| "dbt_mismatches": int(dbt.get("mismatches", 0)),
|
| "soda_mismatches": int(soda.get("mismatches", 0)),
|
| "python_real_llm": bool(py.get("real_llm_used", False)),
|
| "python_provider": py.get("conversion_provider", ""),
|
| "dbt_provider": dbt.get("conversion_provider", ""),
|
| "soda_provider": soda.get("conversion_provider", ""),
|
| "selection_reason": item.get("selection_reason", ""),
|
| "declarative_tie_break_applied": bool(item.get("declarative_tie_break_applied", False)),
|
| "recommendation": item.get("recommendation", ""),
|
| }
|
| )
|
| frame = pd.DataFrame(rows)
|
| if frame.empty:
|
| return frame
|
| return frame.sort_values(by=["best_effective_pct", "rule_name"], ascending=[False, True]).reset_index(drop=True)
|
|
|
|
|
| def _build_effective_chart(frame: pd.DataFrame) -> go.Figure:
|
| chart = frame[["rule_name", "python_effective_pct", "dbt_effective_pct", "soda_effective_pct"]].copy()
|
| chart = chart.melt(id_vars=["rule_name"], var_name="engine", value_name="effective_pct")
|
| chart["engine"] = chart["engine"].str.replace("_effective_pct", "", regex=False).str.upper()
|
| fig = px.bar(
|
| chart,
|
| x="rule_name",
|
| y="effective_pct",
|
| color="engine",
|
| barmode="group",
|
| color_discrete_map={"PYTHON": ENGINE_COLORS["python"], "DBT": ENGINE_COLORS["dbt"], "SODA": ENGINE_COLORS["soda"]},
|
| )
|
| fig.update_layout(
|
| height=460,
|
| margin=dict(l=20, r=20, t=30, b=80),
|
| xaxis=dict(title=None, tickangle=-30),
|
| yaxis=dict(title="Effective confidence (%)", range=[0, 100]),
|
| legend=dict(orientation="h", y=1.08, x=0),
|
| plot_bgcolor="#ffffff",
|
| paper_bgcolor="#ffffff",
|
| )
|
| return fig
|
|
|
|
|
| def _build_best_engine_chart(frame: pd.DataFrame) -> go.Figure:
|
| dist = frame["best_engine"].value_counts().rename_axis("engine").reset_index(name="rules")
|
| fig = px.pie(
|
| dist,
|
| names="engine",
|
| values="rules",
|
| hole=0.58,
|
| color="engine",
|
| color_discrete_map=ENGINE_COLORS,
|
| )
|
| fig.update_layout(height=420, margin=dict(l=5, r=5, t=10, b=10), legend=dict(orientation="h", y=-0.1, x=0))
|
| fig.update_traces(textinfo="label+value")
|
| return fig
|
|
|
|
|
| def _complexity_summary_frame(per_complexity_summary: Mapping[str, Mapping[str, object]]) -> pd.DataFrame:
|
| rows: List[Dict[str, object]] = []
|
| for tier in ("simple", "medium", "intricate", "unknown"):
|
| info = per_complexity_summary.get(tier)
|
| if not info:
|
| continue
|
| rows.append(
|
| {
|
| "complexity": tier,
|
| "rules": int(info.get("rules", 0)),
|
| "python_wins": int(info.get("python_wins", 0)),
|
| "dbt_wins": int(info.get("dbt_wins", 0)),
|
| "soda_wins": int(info.get("soda_wins", 0)),
|
| "avg_best_effective_pct": _to_pct(info.get("avg_best_effective_confidence", 0.0)),
|
| }
|
| )
|
| return pd.DataFrame(rows)
|
|
|
|
|
| def _engine_detail_frame(selected_rule: Mapping[str, object]) -> pd.DataFrame:
|
| rows: List[Dict[str, object]] = []
|
| engines = selected_rule.get("engines", {})
|
| for engine in ("python", "dbt", "soda"):
|
| row = engines.get(engine, {})
|
| rows.append(
|
| {
|
| "engine": engine.upper(),
|
| "status": row.get("status", "n/a"),
|
| "overall_confidence_pct": _to_pct(row.get("overall_confidence", 0.0)),
|
| "effective_confidence_pct": _to_pct(row.get("effective_confidence", row.get("overall_confidence", 0.0))),
|
| "decision_score": float(row.get("decision_score", row.get("effective_confidence", 0.0))),
|
| "parity_ci_low_pct": _to_pct(row.get("parity_ci_lower", 0.0)),
|
| "equivalence_pct": _to_pct(row.get("equivalence_match_rate", 1.0)),
|
| "mutation_pct": _to_pct(row.get("mutation_score", 1.0)),
|
| "verification_pct": _to_pct(row.get("verification_score", 1.0)),
|
| "mismatches": int(row.get("mismatches", 0)),
|
| "provider_factor_pct": _to_pct(row.get("provider_factor", 0.0)),
|
| "provider": row.get("conversion_provider", ""),
|
| "execution_mode": row.get("execution_mode", ""),
|
| "cloud_connected": bool(row.get("cloud_connected", False)),
|
| "cloud_scan_id": row.get("cloud_scan_id", ""),
|
| "cloud_scan_url": row.get("cloud_scan_url", ""),
|
| "real_llm_used": bool(row.get("real_llm_used")) if engine == "python" else None,
|
| "repair_applied": bool(row.get("counterexample_repair_applied", False)) if engine == "python" else None,
|
| "artifact_lines": int(row.get("conversion_lines", 0)),
|
| }
|
| )
|
| return pd.DataFrame(rows)
|
|
|
|
|
| def _engine_artifact(selected_rule: Mapping[str, object], engine: str) -> str:
|
| return str(selected_rule.get("engines", {}).get(engine, {}).get("conversion_artifact", "")).strip()
|
|
|
|
|
| def _engine_failed_cases(selected_rule: Mapping[str, object], engine: str) -> List[Mapping[str, object]]:
|
| return list(selected_rule.get("engines", {}).get(engine, {}).get("failed_test_cases", []))
|
|
|
|
|
| def _engine_equivalence_counterexamples(selected_rule: Mapping[str, object], engine: str) -> List[Mapping[str, object]]:
|
| return list(selected_rule.get("engines", {}).get(engine, {}).get("equivalence_counterexamples", []))
|
|
|
|
|
| def main() -> None:
|
| st.set_page_config(page_title="OFF Migration Comparison Dashboard", layout="wide")
|
| _inject_theme()
|
| st.markdown(
|
| """
|
| <div class="hero">
|
| <h1>Open Food Facts Migration Comparison Dashboard</h1>
|
| <p>Compare Python (LLM), dbt, and Soda migrations for every rule, side-by-side.</p>
|
| </div>
|
| """,
|
| unsafe_allow_html=True,
|
| )
|
|
|
| with st.sidebar:
|
| st.subheader("Comparison Run")
|
| size = st.slider("Dataset size", min_value=100, max_value=500, value=300, step=25)
|
| default_mode = "OFF JSONL" if DEFAULT_SOURCE_JSONL.exists() else "Synthetic"
|
| dataset_mode = st.radio("Dataset mode", options=["OFF JSONL", "Synthetic"], index=0 if default_mode == "OFF JSONL" else 1)
|
| use_off_source = dataset_mode == "OFF JSONL"
|
| seed = st.number_input("Seed (synthetic mode)", min_value=1, max_value=99999, value=17, disabled=use_off_source)
|
| source_jsonl_text = st.text_input("Source JSONL path", value=str(DEFAULT_SOURCE_JSONL), disabled=not use_off_source)
|
| perl_rules_dir_text = st.text_input("Perl rules directory (optional)", value="")
|
| llm_provider = "groq"
|
| st.caption("Python engine uses Groq for LLM conversion in this dashboard.")
|
| llm_model = st.text_input("LLM model override", value="openai/gpt-oss-120b")
|
| soda_mode = st.selectbox(
|
| "Soda mode",
|
| options=["local", "cloud"],
|
| index=0,
|
| help="Use `cloud` to attempt Soda Cloud scan publishing; falls back to local if unavailable.",
|
| )
|
| profile = st.selectbox("Rule profile", options=list(SUPPORTED_PROFILES), index=list(SUPPORTED_PROFILES).index(DEFAULT_PROFILE))
|
| has_groq_key = bool(os.getenv("GROQ_API_KEY"))
|
| if not has_groq_key:
|
| st.warning("GROQ_API_KEY is not set. Python engine will fall back unless key is provided.")
|
|
|
| if st.button("Run Full Comparison"):
|
| try:
|
| if not has_groq_key:
|
| raise RuntimeError("GROQ_API_KEY is required. Set it before running the comparison.")
|
| with st.spinner("Running Python + dbt + Soda comparison..."):
|
| run_engine_comparison(
|
| dataset_size=int(size),
|
| seed=int(seed),
|
| source_jsonl=Path(source_jsonl_text) if use_off_source else None,
|
| use_default_off_source=use_off_source,
|
| llm_provider=llm_provider,
|
| llm_model=llm_model.strip() or None,
|
| perl_rules_dir=Path(perl_rules_dir_text) if perl_rules_dir_text.strip() else None,
|
| results_path=COMPARISON_PATH,
|
| require_real_llm=True,
|
| profile=profile,
|
| soda_mode=soda_mode,
|
| )
|
| st.success("Comparison completed.")
|
| except Exception as exc:
|
| st.error(str(exc))
|
|
|
| payload = load_report()
|
| if not payload:
|
| st.info("No comparison report found yet. Click 'Run Full Comparison' in the sidebar.")
|
| return
|
|
|
| dataset = payload.get("dataset", {})
|
| rule_comparison = list(payload.get("rule_comparison", []))
|
| engine_summary = payload.get("per_engine_summary", {})
|
| complexity_summary = payload.get("per_complexity_summary", {})
|
| run_config = payload.get("run_config", {})
|
| comparison_method = payload.get("comparison_method", {})
|
| comparison_fingerprint = payload.get("comparison_fingerprint", {})
|
| frame = _rule_frame(rule_comparison)
|
| if frame.empty:
|
| st.warning("Comparison report has no rule rows.")
|
| return
|
|
|
| python_wins = int((frame["best_engine"] == "python").sum())
|
| dbt_wins = int((frame["best_engine"] == "dbt").sum())
|
| soda_wins = int((frame["best_engine"] == "soda").sum())
|
| avg_best = frame["best_effective_pct"].mean()
|
| canada_rules = int((frame["jurisdiction"] == "ca").sum()) if "jurisdiction" in frame.columns else 0
|
|
|
| k1, k2, k3 = st.columns(3, gap="large")
|
| with k1:
|
| _render_stat_chip("Rules compared", len(frame))
|
| with k2:
|
| _render_stat_chip("Python wins", python_wins)
|
| with k3:
|
| _render_stat_chip("dbt wins", dbt_wins)
|
| k4, k5, k6 = st.columns(3, gap="large")
|
| with k4:
|
| _render_stat_chip("Soda wins", soda_wins)
|
| with k5:
|
| _render_stat_chip("Avg best effective %", f"{avg_best:.2f}%")
|
| with k6:
|
| _render_stat_chip("Canada rules", canada_rules)
|
|
|
| st.caption(f"Generated at: {payload.get('generated_at_utc', 'n/a')}")
|
| st.caption(f"Dataset size: {dataset.get('products_tested', 'n/a')}")
|
| st.caption(f"Dataset source: {dataset.get('source_jsonl', 'n/a')}")
|
| st.caption(f"Profile: {dataset.get('profile', DEFAULT_PROFILE)}")
|
| st.caption(
|
| "Confidence context: we compare engines using effective confidence "
|
| "(overall confidence x provider factor), with status and mismatches prioritized."
|
| )
|
| if run_config:
|
| st.caption(
|
| f"LLM provider={run_config.get('llm_provider', 'n/a')} | "
|
| f"GROQ key set={run_config.get('groq_api_key_set')} | "
|
| f"Require real LLM={run_config.get('require_real_llm')} | "
|
| f"Run profile={run_config.get('profile', DEFAULT_PROFILE)} | "
|
| f"Soda mode={run_config.get('soda_mode', 'local')} | "
|
| f"Soda Cloud creds set={run_config.get('soda_cloud_credentials_set', False)}"
|
| )
|
| if comparison_fingerprint:
|
| st.caption(
|
| f"Comparison run ID: {comparison_fingerprint.get('comparison_run_id', 'n/a')} | "
|
| f"Run SHA: {str(comparison_fingerprint.get('comparison_sha256', ''))[:12]}"
|
| )
|
| st.caption(
|
| f"Dataset fingerprint: {str(comparison_fingerprint.get('dataset_fingerprint_sha256', ''))[:16]} | "
|
| f"Rulepack fingerprint: {str(comparison_fingerprint.get('rulepack_fingerprint_sha256', ''))[:16]} | "
|
| f"Commit: {str(comparison_fingerprint.get('code_commit', 'unknown'))[:12]}"
|
| )
|
| st.caption(
|
| f"Cross-engine consistency -> "
|
| f"dataset={comparison_fingerprint.get('dataset_fingerprint_consistent', False)} | "
|
| f"rulepack={comparison_fingerprint.get('rulepack_fingerprint_consistent', False)}"
|
| )
|
| selection_lines: List[str] = [
|
| str(
|
| comparison_method.get(
|
| "best_engine_ranking",
|
| "Prefer MATCH status, then fewer mismatches, then higher effective confidence.",
|
| )
|
| )
|
| ]
|
| if comparison_method.get("hybrid_tie_break"):
|
| selection_lines.append(str(comparison_method["hybrid_tie_break"]))
|
| if comparison_method.get("declarative_tie_break"):
|
| selection_lines.append(str(comparison_method["declarative_tie_break"]))
|
| _render_explain_chip("How Best Migration Is Chosen", selection_lines)
|
|
|
| st.subheader("Engine Summary")
|
| summary_frame = _engine_summary_frame(engine_summary)
|
| st.dataframe(
|
| summary_frame,
|
| use_container_width=True,
|
| hide_index=True,
|
| column_config={
|
| "engine": st.column_config.TextColumn("Engine"),
|
| "rules": st.column_config.NumberColumn("Rules", format="%d"),
|
| "passed": st.column_config.NumberColumn("Passed", format="%d"),
|
| "avg_overall_confidence_pct": st.column_config.NumberColumn("Avg overall %", format="%.2f"),
|
| "avg_effective_confidence_pct": st.column_config.NumberColumn("Avg effective %", format="%.2f"),
|
| "avg_parity_ci_low_pct": st.column_config.NumberColumn("Avg parity CI low %", format="%.2f"),
|
| "avg_equivalence_rate_pct": st.column_config.NumberColumn("Avg equivalence %", format="%.2f"),
|
| "avg_mutation_score_pct": st.column_config.NumberColumn("Avg mutation %", format="%.2f"),
|
| "fallback_rules": st.column_config.NumberColumn("Fallback rules", format="%d"),
|
| "real_llm_rules": st.column_config.NumberColumn("Real LLM rules", format="%d"),
|
| "real_llm_rate_pct": st.column_config.NumberColumn("Real LLM rate %", format="%.2f"),
|
| "repairs_applied": st.column_config.NumberColumn("Repairs applied", format="%d"),
|
| },
|
| )
|
|
|
| complexity_frame = _complexity_summary_frame(complexity_summary)
|
| if not complexity_frame.empty:
|
| st.subheader("Mixed-Complexity Benchmark Summary")
|
| st.dataframe(
|
| complexity_frame,
|
| use_container_width=True,
|
| hide_index=True,
|
| column_config={
|
| "complexity": st.column_config.TextColumn("Complexity tier"),
|
| "rules": st.column_config.NumberColumn("Rules", format="%d"),
|
| "python_wins": st.column_config.NumberColumn("Python wins", format="%d"),
|
| "dbt_wins": st.column_config.NumberColumn("dbt wins", format="%d"),
|
| "soda_wins": st.column_config.NumberColumn("Soda wins", format="%d"),
|
| "avg_best_effective_pct": st.column_config.NumberColumn("Avg best effective %", format="%.2f"),
|
| },
|
| )
|
|
|
| left, right = st.columns([0.72, 0.28], gap="large")
|
| with left:
|
| st.subheader("Effective Confidence by Rule and Engine")
|
| st.plotly_chart(_build_effective_chart(frame), use_container_width=True)
|
| with right:
|
| st.subheader("Best Engine Distribution")
|
| st.plotly_chart(_build_best_engine_chart(frame), use_container_width=True)
|
|
|
| st.subheader("Rule Validation Table (Comparison View)")
|
| show_advanced = st.checkbox("Show advanced metrics", value=False)
|
| show_providers = st.checkbox("Show provider columns", value=False)
|
| jurisdictions = sorted(frame["jurisdiction"].dropna().unique().tolist())
|
| selected_jurisdictions = st.multiselect("Filter jurisdiction", options=jurisdictions, default=jurisdictions)
|
| table_frame = frame[frame["jurisdiction"].isin(selected_jurisdictions)] if selected_jurisdictions else frame
|
| columns = [
|
| "rule_name",
|
| "jurisdiction",
|
| "regulatory_type",
|
| "review_status",
|
| "legal_citation",
|
| "complexity",
|
| "condition_type",
|
| "severity",
|
| "best_engine",
|
| "best_effective_pct",
|
| "decision_margin",
|
| "recommendation",
|
| ]
|
| if show_advanced:
|
| columns.extend(
|
| [
|
| "best_decision_score",
|
| "effective_margin_pct",
|
| "python_effective_pct",
|
| "dbt_effective_pct",
|
| "soda_effective_pct",
|
| "python_equivalence_pct",
|
| "python_mutation_pct",
|
| "python_verification_pct",
|
| "python_repair_applied",
|
| "python_mismatches",
|
| "dbt_mismatches",
|
| "soda_mismatches",
|
| "python_real_llm",
|
| "declarative_tie_break_applied",
|
| "selection_reason",
|
| ]
|
| )
|
| if show_providers:
|
| columns.extend(["python_provider", "dbt_provider", "soda_provider"])
|
| st.dataframe(
|
| table_frame[columns],
|
| use_container_width=True,
|
| hide_index=True,
|
| column_config={
|
| "rule_name": st.column_config.TextColumn("Rule"),
|
| "jurisdiction": st.column_config.TextColumn("Jurisdiction"),
|
| "regulatory_type": st.column_config.TextColumn("Regulatory type"),
|
| "review_status": st.column_config.TextColumn("Review status"),
|
| "legal_citation": st.column_config.TextColumn("Legal citation"),
|
| "complexity": st.column_config.TextColumn("Complexity"),
|
| "condition_type": st.column_config.TextColumn("Condition type"),
|
| "severity": st.column_config.TextColumn("Severity"),
|
| "best_engine": st.column_config.TextColumn("Best migration"),
|
| "best_effective_pct": st.column_config.NumberColumn("Best effective %", format="%.2f"),
|
| "best_decision_score": st.column_config.NumberColumn("Best decision score", format="%.4f"),
|
| "effective_margin_pct": st.column_config.NumberColumn("Win margin %", format="%.2f"),
|
| "decision_margin": st.column_config.NumberColumn("Score margin", format="%.4f"),
|
| "python_effective_pct": st.column_config.NumberColumn("Python effective %", format="%.2f"),
|
| "dbt_effective_pct": st.column_config.NumberColumn("dbt effective %", format="%.2f"),
|
| "soda_effective_pct": st.column_config.NumberColumn("Soda effective %", format="%.2f"),
|
| "python_equivalence_pct": st.column_config.NumberColumn("Python equiv %", format="%.2f"),
|
| "python_mutation_pct": st.column_config.NumberColumn("Python mutation %", format="%.2f"),
|
| "python_verification_pct": st.column_config.NumberColumn("Python verify %", format="%.2f"),
|
| "python_repair_applied": st.column_config.CheckboxColumn("Repair applied"),
|
| "python_mismatches": st.column_config.NumberColumn("Python mismatches", format="%d"),
|
| "dbt_mismatches": st.column_config.NumberColumn("dbt mismatches", format="%d"),
|
| "soda_mismatches": st.column_config.NumberColumn("Soda mismatches", format="%d"),
|
| "python_real_llm": st.column_config.CheckboxColumn("Python real LLM"),
|
| "declarative_tie_break_applied": st.column_config.CheckboxColumn("dbt/soda tie-break"),
|
| "selection_reason": st.column_config.TextColumn("Selection reason"),
|
| "recommendation": st.column_config.TextColumn("Recommendation"),
|
| "python_provider": st.column_config.TextColumn("Python provider"),
|
| "dbt_provider": st.column_config.TextColumn("dbt provider"),
|
| "soda_provider": st.column_config.TextColumn("Soda provider"),
|
| },
|
| )
|
|
|
| st.subheader("Rule Detail")
|
| rule_names = [row.get("rule_name", "") for row in rule_comparison]
|
| selected_rule_name = st.selectbox("Select rule", rule_names)
|
| selected_rule = next(row for row in rule_comparison if row.get("rule_name") == selected_rule_name)
|
|
|
| d1, d2, d3 = st.columns(3, gap="large")
|
| with d1:
|
| _render_stat_chip("Best migration", str(selected_rule.get("best_engine", "n/a")).upper())
|
| with d2:
|
| _render_stat_chip("Severity", str(selected_rule.get("severity", "n/a")))
|
| with d3:
|
| _render_stat_chip("Products tested", int(selected_rule.get("products_tested", 0)))
|
| best_engine = str(selected_rule.get("best_engine", "python"))
|
| best_effective = selected_rule.get("engines", {}).get(best_engine, {}).get("effective_confidence", 0.0)
|
| detail_row = frame.loc[frame["rule_name"] == selected_rule_name].iloc[0]
|
| d4, d5 = st.columns(2, gap="large")
|
| with d4:
|
| _render_stat_chip("Best effective %", f"{_to_pct(best_effective):.2f}")
|
| with d5:
|
| _render_stat_chip("Decision margin", f"{float(detail_row['decision_margin']):.4f}")
|
|
|
| st.caption(f"Condition: {selected_rule.get('condition', 'n/a')}")
|
| st.caption(f"Rule IR hash: {selected_rule.get('rule_ir_hash', 'n/a')}")
|
| st.caption(f"Condition type: {selected_rule.get('condition_type', 'n/a')}")
|
| st.caption(f"Complexity tier: {selected_rule.get('complexity', 'n/a')}")
|
| st.caption(f"Declarative friendly: {selected_rule.get('declarative_friendly', 'n/a')}")
|
| st.caption(f"Jurisdiction: {selected_rule.get('jurisdiction', 'global')}")
|
| st.caption(f"Regulatory type: {selected_rule.get('regulatory_type', 'n/a')}")
|
| st.caption(f"Legal citation: {selected_rule.get('legal_citation', 'n/a')}")
|
| source_url = str(selected_rule.get("source_url", "")).strip()
|
| if source_url:
|
| st.markdown(f"Source URL: [{source_url}]({source_url})")
|
| else:
|
| st.caption("Source URL: n/a")
|
| st.caption(f"Effective date: {selected_rule.get('effective_date', 'n/a')}")
|
| st.caption(f"Review status: {selected_rule.get('review_status', 'n/a')}")
|
| st.caption(f"Reviewer: {selected_rule.get('reviewer', 'n/a')}")
|
| st.caption(f"Exemption logic: {selected_rule.get('exemption_logic', 'n/a')}")
|
| st.caption(f"Selection reason: {selected_rule.get('selection_reason', 'n/a')}")
|
| st.caption(f"dbt/soda explicit tie-break applied: {selected_rule.get('declarative_tie_break_applied', False)}")
|
| st.caption(f"Recommendation: {selected_rule.get('recommendation', 'n/a')}")
|
| soda_meta = selected_rule.get("engines", {}).get("soda", {})
|
| st.caption(
|
| "Soda execution: "
|
| f"mode={soda_meta.get('execution_mode', 'n/a')} | "
|
| f"cloud_connected={soda_meta.get('cloud_connected', False)} | "
|
| f"scan_id={soda_meta.get('cloud_scan_id', '') or 'n/a'}"
|
| )
|
| soda_scan_url = str(soda_meta.get("cloud_scan_url", "")).strip()
|
| if soda_scan_url:
|
| st.markdown(f"Soda Cloud scan URL: [{soda_scan_url}]({soda_scan_url})")
|
|
|
| st.markdown("**Engine metrics for selected rule**")
|
| st.dataframe(
|
| _engine_detail_frame(selected_rule),
|
| use_container_width=True,
|
| hide_index=True,
|
| column_config={
|
| "engine": st.column_config.TextColumn("Engine"),
|
| "status": st.column_config.TextColumn("Status"),
|
| "overall_confidence_pct": st.column_config.NumberColumn("Overall %", format="%.2f"),
|
| "effective_confidence_pct": st.column_config.NumberColumn("Effective %", format="%.2f"),
|
| "decision_score": st.column_config.NumberColumn("Decision score", format="%.4f"),
|
| "parity_ci_low_pct": st.column_config.NumberColumn("Parity CI low %", format="%.2f"),
|
| "equivalence_pct": st.column_config.NumberColumn("Equivalence %", format="%.2f"),
|
| "mutation_pct": st.column_config.NumberColumn("Mutation %", format="%.2f"),
|
| "verification_pct": st.column_config.NumberColumn("Verification %", format="%.2f"),
|
| "mismatches": st.column_config.NumberColumn("Mismatches", format="%d"),
|
| "provider_factor_pct": st.column_config.NumberColumn("Provider factor %", format="%.2f"),
|
| "provider": st.column_config.TextColumn("Provider"),
|
| "execution_mode": st.column_config.TextColumn("Execution mode"),
|
| "cloud_connected": st.column_config.CheckboxColumn("Cloud connected"),
|
| "cloud_scan_id": st.column_config.TextColumn("Cloud scan ID"),
|
| "cloud_scan_url": st.column_config.TextColumn("Cloud scan URL"),
|
| "real_llm_used": st.column_config.CheckboxColumn("Real LLM used"),
|
| "repair_applied": st.column_config.CheckboxColumn("Repair applied"),
|
| "artifact_lines": st.column_config.NumberColumn("Artifact lines", format="%d"),
|
| },
|
| )
|
|
|
| st.markdown("**All three migration artifacts for this rule**")
|
| c1, c2, c3 = st.columns(3, gap="large")
|
| with c1:
|
| st.markdown("`PYTHON`")
|
| st.code(_engine_artifact(selected_rule, "python"), language="python")
|
| with c2:
|
| st.markdown("`DBT`")
|
| st.code(_engine_artifact(selected_rule, "dbt"), language="sql")
|
| with c3:
|
| st.markdown("`SODA`")
|
| st.code(_engine_artifact(selected_rule, "soda"), language="yaml")
|
|
|
| st.markdown("**Python Equivalence Counterexamples**")
|
| python_counterexamples = _engine_equivalence_counterexamples(selected_rule, "python")
|
| if python_counterexamples:
|
| st.dataframe(pd.DataFrame(python_counterexamples), use_container_width=True, hide_index=True)
|
| else:
|
| st.success("No Python equivalence counterexamples.")
|
|
|
| st.markdown("**Parity mismatch samples by engine**")
|
| for engine, title in [("python", "Python"), ("dbt", "dbt"), ("soda", "Soda")]:
|
| st.markdown(f"`{title}`")
|
| failed_cases = _engine_failed_cases(selected_rule, engine)
|
| if failed_cases:
|
| st.dataframe(pd.DataFrame(failed_cases), use_container_width=True, hide_index=True)
|
| else:
|
| st.success(f"No mismatches for {title}.")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
