Upload 5 files

README.md

@@ -1,14 +1,18 @@
----
-title: Cmp
-emoji: 🏃
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-sdk_version: 6.12.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: cmp
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Congress Public Records Slice Space
+
+Neutral Records explorer for a public-record slice of congressional money-and-power linkages.
+
+## Runtime Notes
+
+- This Space reads the sanitized dataset bundle from the configured Hugging Face dataset repo.
+- For local testing, set `local_dataset_root` in `public_copy.json` or regenerate the bundle with a local preview root.
+- The Space is intentionally neutral and does not assign guilt, wrongdoing, intent, or causality.
+
+## Required Caveats
+
+- This release is a slice of public-record data, not a complete accounting of all potentially relevant data.
+- Future releases may update or expand this slice as source recovery, parsing, and evidence linkage improve.
+- This release does not assign guilt, wrongdoing, intent, or causality to any person or organization.
+- The release shows public-record overlaps, timing, and linkage strength, not proof of illegality or corruption.
+- Some rows remain review-tier or include unresolved official source references and should be read with those labels in mind.
+- The public package includes verification summaries and SHA-backed artifact indexes, but it does not include the full internal raw corpus, so external verification is bounded by what is published here.

app.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from public_space_app import build_app
+
+APP_DIR = Path(__file__).resolve().parent
+app = build_app(APP_DIR / "public_copy.json")
+
+if __name__ == "__main__":
+    app.launch()

public_copy.json

@@ -0,0 +1,10 @@
+{
+  "public_version": "congress-public-records-slice-2026-04-v1",
+  "title": "Congress Public Records Slice",
+  "subtitle": "Neutral Records explorer for a public-record slice of congressional money-and-power linkages.",
+  "dataset_repo_id": "cjc0013/cmp-data",
+  "space_repo_id": "cjc0013/cmp",
+  "landing_markdown": "# Congress Public Records Slice\n\nA neutral, review-oriented slice of House public-record linkages across financial disclosures, sector overlap, and community project funding recipient relationships.\n\n- This release is a slice of public-record data, not a complete accounting of all potentially relevant data.\n- Future releases may update or expand this slice as source recovery, parsing, and evidence linkage improve.\n- This release does not assign guilt, wrongdoing, intent, or causality to any person or organization.\n- The release shows public-record overlaps, timing, and linkage strength, not proof of illegality or corruption.\n- Some rows remain review-tier or include unresolved official source references and should be read with those labels in mind.\n- The public package includes verification summaries and SHA-backed artifact indexes, but it does not include the full internal raw corpus, so external verification is bounded by what is published here.",
+  "downloads_markdown": "## Downloads\n\n- Dataset repo id: `cjc0013/cmp-data`\n- Space repo id: `cjc0013/cmp`\n\nUse the dataset bundle files for direct review, CSV download, and SHA-backed source checks.",
+  "dataset_bundle_prefix": "dataset_bundle"
+}

public_space_app.py

@@ -0,0 +1,466 @@
+from __future__ import annotations
+
+import html
+import json
+import os
+import urllib.request
+from pathlib import Path
+from typing import Any, Dict, Tuple
+
+import pandas as pd
+
+try:
+    import gradio as gr
+except ImportError as exc:  # pragma: no cover - runtime dependency
+    raise RuntimeError("gradio is required to run this Space bundle") from exc
+
+try:
+    from pyvis.network import Network
+except ImportError as exc:  # pragma: no cover - runtime dependency
+    raise RuntimeError("pyvis is required to run this Space bundle") from exc
+
+
+def _read_json(source: str) -> Dict[str, Any]:
+    if source.startswith("http://") or source.startswith("https://"):
+        with urllib.request.urlopen(source) as response:
+            return json.loads(response.read().decode("utf-8"))
+    return json.loads(Path(source).read_text(encoding="utf-8"))
+
+
+def _read_jsonl(source: str) -> pd.DataFrame:
+    if source.startswith("http://") or source.startswith("https://"):
+        with urllib.request.urlopen(source) as response:
+            lines = response.read().decode("utf-8").splitlines()
+    else:
+        lines = Path(source).read_text(encoding="utf-8").splitlines()
+    rows = [json.loads(line) for line in lines if line.strip()]
+    return pd.DataFrame(rows)
+
+
+def _dataset_path(copy_payload: Dict[str, Any], relative_path: str) -> str:
+    local_root_value = os.environ.get("PUBLIC_RELEASE_LOCAL_ROOT", "").strip()
+    local_root = Path(local_root_value).resolve() if local_root_value else None
+    if local_root and (local_root / relative_path).exists():
+        return str(local_root / relative_path)
+    repo_id = str(copy_payload.get("dataset_repo_id") or "").strip()
+    if not repo_id:
+        raise FileNotFoundError(f"Dataset repo id is not configured for {relative_path}")
+    return f"https://huggingface.co/datasets/{repo_id}/resolve/main/{relative_path}"
+
+
+def load_release_data(copy_path: str | Path) -> Dict[str, Any]:
+    copy_payload = json.loads(Path(copy_path).read_text(encoding="utf-8"))
+    bundle_root = copy_payload.get("dataset_bundle_prefix", "dataset_bundle")
+    def path_for(name: str) -> str:
+        return _dataset_path(copy_payload, f"{bundle_root}/{name}")
+    return {
+        "copy": copy_payload,
+        "manifest": _read_json(path_for("public_release_manifest.json")),
+        "members": pd.read_csv(path_for("members.csv")),
+        "events": pd.read_csv(path_for("scored_events.csv")),
+        "links": pd.read_csv(path_for("graph_links.csv")),
+        "recipient_link_quality": _read_json(path_for("recipient_link_quality_report.json")),
+        "source_quality": _read_json(path_for("source_quality_report.json")),
+        "provenance_coverage": _read_json(path_for("provenance_coverage_report.json")),
+        "graph_nodes": pd.read_csv(path_for("network_graph/nodes.csv")),
+        "graph_edges": pd.read_csv(path_for("network_graph/edges.csv")),
+        "graph_config": _read_json(path_for("network_graph/graph_config.json")),
+        "artifact_index": pd.read_csv(path_for("evidence_audit/source_artifact_index.csv")),
+        "event_audit": pd.read_csv(path_for("evidence_audit/scored_event_index.csv")),
+        "event_provenance": _read_jsonl(path_for("evidence_audit/scored_event_provenance.jsonl")),
+        "consistency": _read_json(path_for("evidence_audit/consistency_report.json")),
+    }
+
+
+def _member_search_mask(frame: pd.DataFrame, query: str) -> pd.Series:
+    if not query.strip():
+        return pd.Series([True] * len(frame), index=frame.index)
+    name_series = frame.get("member_name", pd.Series("", index=frame.index)).fillna("")
+    slug_series = frame.get("member_slug", pd.Series("", index=frame.index)).fillna("")
+    return name_series.str.contains(query, case=False, na=False) | slug_series.str.contains(query, case=False, na=False)
+
+
+def _plain_status_label(value: str) -> str:
+    normalized = str(value or "").strip()
+    mapping = {
+        "release_ok": "Stronger support",
+        "linked": "Stronger support",
+        "needs_review": "Needs review / caution",
+        "acceptable_with_label": "Usable with caveats",
+        "unresolved": "Unresolved",
+        "stronger": "Stronger support",
+        "all": "All shown relationships",
+    }
+    return mapping.get(normalized, normalized.replace("_", " ").title() or "Unknown")
+
+
+def _plain_status_explainer(value: str) -> str:
+    normalized = str(value or "").strip()
+    mapping = {
+        "release_ok": "The released slice has clearer public support for this relationship.",
+        "linked": "The released slice has clearer public support for this relationship.",
+        "needs_review": "There is some support for this relationship, but it should be read with caution.",
+        "acceptable_with_label": "This relationship is usable in the release, but some caveats remain visible.",
+        "unresolved": "The released slice does not yet have enough public support to present this relationship as stronger.",
+    }
+    return mapping.get(normalized, "This relationship should be interpreted together with the attached evidence and caveats.")
+
+
+def _plain_family_label(value: str) -> str:
+    normalized = str(value or "").strip()
+    return {
+        "recipient": "Funding recipients",
+        "sector": "Sectors",
+        "all": "All relationships",
+    }.get(normalized, normalized.replace("_", " ").title() or "Relationships")
+
+
+def _plain_score_label(value: str) -> str:
+    normalized = str(value or "").strip()
+    return {
+        "strong_sector_overlap": "Stronger sector overlap",
+        "weak_sector_overlap": "Weaker sector overlap",
+        "all": "All score labels",
+    }.get(normalized, normalized.replace("_", " ").title() or "Score label")
+
+
+def _trim_to_overview_members(edges: pd.DataFrame, max_members: int) -> pd.DataFrame:
+    if edges.empty or max_members <= 0:
+        return edges
+    member_totals = (
+        edges.groupby(["member_slug", "member_name"], dropna=False)
+        .agg(total_link_count=("link_count", "sum"), edge_count=("edge_id", "count"))
+        .reset_index()
+        .sort_values(["total_link_count", "edge_count", "member_name"], ascending=[False, False, True])
+    )
+    keep_slugs = {
+        str(value)
+        for value in member_totals["member_slug"].head(max_members).tolist()
+        if str(value).strip()
+    }
+    if not keep_slugs:
+        return edges
+    return edges[edges["member_slug"].isin(keep_slugs)]
+
+
+def _graph_intro_markdown(config: Dict[str, Any]) -> str:
+    node_counts = config.get("node_counts") or {}
+    edge_counts = config.get("edge_counts") or {}
+    status_counts = config.get("relationship_status_counts") or {}
+    defaults = config.get("default_filters") or {}
+    example_members = [str(item) for item in (config.get("example_member_searches") or []) if str(item).strip()]
+    return "\n".join(
+        [
+            "### What you are looking at",
+            "",
+            "- Green dots are House members, rust dots are funding recipients, and gold dots are sectors.",
+            "- Thicker lines mean more supporting relationship rows in this released slice.",
+            f"- This graph opens in a simpler `{_plain_family_label(str(defaults.get('relationship_family', 'sector'))).lower()}` overview so the first screen is easier to read.",
+            f"- The default status filter is `{_plain_status_label(str(defaults.get('review_status', 'stronger'))).lower()}`.",
+            f"- Unresolved-only edges start hidden: `{str(bool(defaults.get('hide_unresolved_only', True))).lower()}`.",
+            *([f"- Example member searches: {', '.join(f'`{item}`' for item in example_members)}."] if example_members else []),
+            f"- Current graph inventory: `{int(node_counts.get('member', 0) or 0)}` members, `{int(node_counts.get('recipient', 0) or 0)}` recipients, `{int(node_counts.get('sector', 0) or 0)}` sectors.",
+            f"- Relationship counts: `{int(edge_counts.get('recipient', 0) or 0)}` recipient edges, `{int(edge_counts.get('sector', 0) or 0)}` sector edges.",
+            f"- Stronger-support relationships in this slice: `{int(status_counts.get('linked', 0) or 0) + int(status_counts.get('release_ok', 0) or 0)}`.",
+            f"- Needs-review relationships in this slice: `{int(status_counts.get('needs_review', 0) or 0)}`.",
+            f"- Unresolved relationships in this slice: `{int(status_counts.get('unresolved', 0) or 0)}`.",
+        ]
+    )
+
+
+def _filter_events(events: pd.DataFrame, member_query: str, event_type: str, score_label: str, text_query: str) -> pd.DataFrame:
+    filtered = events.copy()
+    if member_query.strip():
+        filtered = filtered[_member_search_mask(filtered, member_query)]
+    if event_type != "all":
+        filtered = filtered[filtered["event_type"] == event_type]
+    if score_label != "all":
+        filtered = filtered[filtered["score_label"] == score_label]
+    if text_query.strip():
+        mask = filtered["issuer_raw"].fillna("").str.contains(text_query, case=False, na=False)
+        mask = mask | filtered["sector"].fillna("").str.contains(text_query, case=False, na=False)
+        filtered = filtered[mask]
+    return filtered
+
+
+def _filter_graph(
+    edges: pd.DataFrame,
+    family: str,
+    member_query: str,
+    target_query: str,
+    score_label: str,
+    review_status: str,
+    hide_unresolved_only: bool,
+    max_edges: int,
+    overview_member_limit: int,
+) -> pd.DataFrame:
+    filtered = edges.copy()
+    if family != "all":
+        filtered = filtered[filtered["relationship_family"] == family]
+    if member_query.strip():
+        filtered = filtered[_member_search_mask(filtered, member_query)]
+    if target_query.strip():
+        filtered = filtered[filtered["target_label"].fillna("").str.contains(target_query, case=False, na=False)]
+    if score_label != "all":
+        filtered = filtered[filtered["score_labels"].fillna("").str.contains(score_label, case=False, na=False)]
+    if review_status == "stronger":
+        filtered = filtered[filtered["relationship_status"].isin(["linked", "release_ok"])]
+    elif review_status != "all":
+        filtered = filtered[filtered["relationship_status"] == review_status]
+    if hide_unresolved_only:
+        filtered = filtered[filtered["relationship_status"] != "unresolved"]
+    filtered = filtered.sort_values(["link_count", "strong_event_count", "linked_count"], ascending=[False, False, False])
+    if not member_query.strip() and not target_query.strip():
+        filtered = _trim_to_overview_members(filtered, int(overview_member_limit))
+        filtered = filtered.sort_values(["link_count", "strong_event_count", "linked_count"], ascending=[False, False, False])
+    return filtered.head(int(max_edges))
+
+
+def _split_pipe_values(value: Any, *, limit: int | None = None) -> list[str]:
+    items = [item.strip() for item in str(value or "").split(" | ") if item and item.strip()]
+    if limit is not None:
+        return items[:limit]
+    return items
+
+
+def _consistency_summary_markdown(consistency: Dict[str, Any]) -> str:
+    event_payload = consistency.get("event_provenance") or {}
+    claim_payload = consistency.get("claim_supporting_provenance") or {}
+    return "\n".join(
+        [
+            "### Audit Summary",
+            "",
+            f"- Event rows in the audit index: `{int(event_payload.get('event_count', 0) or 0)}`",
+            f"- Event rows with attached artifacts: `{int(event_payload.get('events_with_artifacts', 0) or 0)}`",
+            f"- Stored-versus-lookup provenance mismatches: `{int(event_payload.get('stored_lookup_mismatch_count', 0) or 0)}`",
+            f"- Claim-supporting rows in the audit index: `{int(claim_payload.get('row_count', 0) or 0)}`",
+            f"- Claim-supporting rows with attached artifacts: `{int(claim_payload.get('rows_with_artifacts', 0) or 0)}`",
+            "",
+            "Use the tables below to inspect the public source URLs and SHA-backed artifacts that support the released rows.",
+        ]
+    )
+
+
+def _render_graph(nodes: pd.DataFrame, edges: pd.DataFrame) -> str:
+    if edges.empty:
+        return "<div style=\"padding: 1rem; border: 1px solid #d6d0c4; background: #fffdf8; color: #3a3a3a;\">No relationships match the current filters.</div>"
+    network = Network(height="720px", width="100%", bgcolor="#fbf7ee", font_color="#1f2b2d")
+    network.barnes_hut(gravity=-15000, central_gravity=0.15, spring_length=220, spring_strength=0.02)
+    network.set_options("""
+    var options = {
+      "interaction": {"hover": true, "tooltipDelay": 120, "navigationButtons": true, "keyboard": true},
+      "physics": {"stabilization": {"enabled": true, "iterations": 250}}
+    }
+    """)
+    color_map = {"member": "#1f5f5b", "recipient": "#a24e2c", "sector": "#c08d2e"}
+    edge_style_map = {
+        "linked": {"color": "#2f7d4a", "dashes": False},
+        "release_ok": {"color": "#2f7d4a", "dashes": False},
+        "needs_review": {"color": "#c67f00", "dashes": True},
+        "acceptable_with_label": {"color": "#b68b2a", "dashes": True},
+        "unresolved": {"color": "#9aa0a6", "dashes": True},
+    }
+    node_rows = nodes.set_index("node_id").to_dict("index")
+    for node_id in set(edges["source_node_id"]).union(set(edges["target_node_id"])):
+        node = node_rows.get(node_id)
+        if not node:
+            continue
+        node_type = str(node.get("node_type", ""))
+        title_lines = [f"<b>{html.escape(str(node.get('label', '')))}</b>"]
+        role_label = {
+            "member": "House member",
+            "recipient": "Funding recipient",
+            "sector": "Sector",
+        }.get(node_type, node_type.title())
+        title_lines.append(f"Role: {html.escape(role_label)}")
+        if node_type == "member":
+            party = str(node.get("party", "") or "").strip()
+            state = str(node.get("state", "") or "").strip()
+            if party or state:
+                title_lines.append(f"Party / State: {html.escape(' '.join(item for item in [party, state] if item))}")
+        title_lines.append(f"Released relationships in graph data: {int(node.get('connected_edge_count', 0) or 0)}")
+        network.add_node(
+            node_id,
+            label=str(node.get("label", "")),
+            title="<br>".join(title_lines),
+            color=color_map.get(str(node.get("node_type", "")), "#6e6e6e"),
+            shape="dot",
+            size=16 + min(int(node.get("connected_edge_count", 0) or 0), 20),
+        )
+    for row in edges.to_dict("records"):
+        status = str(row.get("relationship_status", "") or "")
+        source_urls = [item for item in str(row.get("source_urls", "") or "").split(" | ") if item]
+        source_preview = "<br>".join(html.escape(item) for item in source_urls[:3]) or "No public URLs attached in this edge summary."
+        family_label = _plain_family_label(str(row.get("relationship_family", "")))
+        score_labels = [
+            _plain_score_label(part.split(":", 1)[0])
+            for part in str(row.get("score_labels", "") or "").split(" | ")
+            if ":" in part
+        ]
+        title_lines = [
+            f"<b>{html.escape(str(row.get('member_name', '') or row.get('member_slug', '')))} -> {html.escape(str(row.get('target_label', '')))}</b>",
+            f"Relationship type: {html.escape(family_label)}",
+            f"Presentation tier: {html.escape(_plain_status_label(status))}",
+            html.escape(_plain_status_explainer(status)),
+            f"Supporting relationship rows in this slice: {int(row.get('link_count', 0) or 0)}",
+        ]
+        if str(row.get("relationship_family", "") or "").strip() == "recipient":
+            title_lines.append(f"Stronger-support rows: {int(row.get('linked_count', 0) or 0)}")
+            title_lines.append(f"Needs-review rows: {int(row.get('review_count', 0) or 0)}")
+        else:
+            title_lines.append(f"Stronger sector-overlap events: {int(row.get('strong_event_count', 0) or 0)}")
+            title_lines.append(f"Weaker sector-overlap events: {int(row.get('weak_event_count', 0) or 0)}")
+        if score_labels:
+            title_lines.append(f"Score labels: {html.escape(', '.join(score_labels[:4]))}")
+        unresolved_count = int(row.get("unresolved_source_ref_count", 0) or 0)
+        if unresolved_count:
+            title_lines.append(f"Unresolved source references still counted: {unresolved_count}")
+        if source_urls:
+            title_lines.append("Example source URLs:")
+            title_lines.append(source_preview)
+        edge_style = edge_style_map.get(status, {"color": "#7b7b7b", "dashes": False})
+        network.add_edge(
+            str(row.get("source_node_id", "")),
+            str(row.get("target_node_id", "")),
+            value=max(int(row.get("link_count", 1) or 1), 1),
+            width=1 + min(int(row.get("link_count", 1) or 1), 8),
+            title="<br>".join(title_lines),
+            color=edge_style["color"],
+            dashes=edge_style["dashes"],
+        )
+    return network.generate_html(notebook=False)
+
+
+def _event_detail(events: pd.DataFrame, provenance: pd.DataFrame, event_id: str) -> Tuple[str, pd.DataFrame]:
+    if not event_id or event_id not in set(events["event_id"]):
+        return "Select an event id to inspect source URLs and SHA-backed artifacts.", pd.DataFrame()
+    event_row = events[events["event_id"] == event_id].head(1).to_dict("records")[0]
+    prov_rows = provenance[provenance["row_key"] == event_id]
+    member_name = str(event_row.get("member_name") or event_row.get("member_slug") or "Unknown member")
+    event_type = str(event_row.get("event_type") or "").replace("_", " ").strip() or "unspecified event"
+    score_label = _plain_score_label(str(event_row.get("score_label") or ""))
+    issuer_raw = str(event_row.get("issuer_raw") or "").strip()
+    sector = str(event_row.get("sector") or "").strip()
+    reason_codes = _split_pipe_values(event_row.get("reason_codes", ""))
+    missing_to_strengthen = _split_pipe_values(event_row.get("missing_to_strengthen", ""))
+    source_urls = _split_pipe_values(event_row.get("source_urls", ""), limit=5)
+    sha_values = _split_pipe_values(event_row.get("sha256_values", ""), limit=5)
+    lines = [
+        f"### {member_name}",
+        "",
+        "This panel summarizes one released event row from the public slice.",
+        "",
+        f"- Event id: `{event_id}`",
+        f"- Event type: `{event_type}`",
+    ]
+    if score_label:
+        lines.append(f"- Score label: `{score_label}`")
+    confidence_bucket = str(event_row.get("confidence_bucket") or "").strip()
+    if confidence_bucket:
+        lines.append(f"- Confidence bucket: `{confidence_bucket}`")
+    if issuer_raw:
+        lines.append(f"- Issuer or subject: `{issuer_raw}`")
+    if sector:
+        lines.append(f"- Sector: `{sector}`")
+    lines.extend(
+        [
+            f"- Attached source URLs in this row: `{int(event_row.get('source_ref_count', 0) or 0)}`",
+            f"- SHA-backed artifacts attached: `{int(event_row.get('sha_backed_source_artifact_count', 0) or 0)}`",
+            f"- Unresolved source references still counted: `{int(event_row.get('unresolved_source_ref_count', 0) or 0)}`",
+            f"- Matching provenance rows shown below: `{len(prov_rows)}`",
+        ]
+    )
+    if reason_codes:
+        lines.extend(["", "#### Why this row appears", ""])
+        lines.extend(f"- `{item}`" for item in reason_codes[:8])
+    if missing_to_strengthen:
+        lines.extend(["", "#### What would strengthen it", ""])
+        lines.extend(f"- `{item}`" for item in missing_to_strengthen[:8])
+    if source_urls:
+        lines.extend(["", "#### Example source URLs", ""])
+        lines.extend(f"- {item}" for item in source_urls)
+    if sha_values:
+        lines.extend(["", "#### Example SHA-256 values", ""])
+        lines.extend(f"- `{item}`" for item in sha_values)
+    return "\n".join(lines), prov_rows
+
+
+def build_app(copy_path: str | Path):
+    data = load_release_data(copy_path)
+    events = data["events"]
+    links = data["links"]
+    nodes = data["graph_nodes"]
+    edges = data["graph_edges"]
+    provenance = data["event_provenance"]
+    copy_payload = data["copy"]
+
+    event_type_choices = ["all"] + sorted(value for value in events["event_type"].dropna().unique().tolist())
+    score_label_choices = ["all"] + sorted(value for value in events["score_label"].dropna().unique().tolist())
+    graph_score_choices = [("All score labels", "all")] + [
+        (_plain_score_label(value), value)
+        for value in sorted(value for value in data["graph_config"].get("available_score_labels") or [])
+    ]
+    graph_status_choices = [
+        ("All shown relationships", "all"),
+        ("Stronger support", "stronger"),
+        ("Needs review / caution", "needs_review"),
+        ("Usable with caveats", "acceptable_with_label"),
+        ("Unresolved", "unresolved"),
+    ]
+    graph_family_choices = [
+        ("Sectors", "sector"),
+        ("Funding recipients", "recipient"),
+        ("All relationships", "all"),
+    ]
+    event_id_choices = sorted(events["event_id"].dropna().unique().tolist())
+    graph_defaults = data["graph_config"].get("default_filters") or {}
+    overview_member_limit = int(graph_defaults.get("overview_member_limit", 8))
+
+    with gr.Blocks(title=copy_payload.get("title", "Congress Public Records Slice")) as app:
+        gr.Markdown(copy_payload.get("landing_markdown", ""))
+        with gr.Tab("Explore"):
+            with gr.Row():
+                member_query = gr.Textbox(label="Member name or slug")
+                event_type = gr.Dropdown(label="Event type", choices=event_type_choices, value="all")
+                score_label = gr.Dropdown(label="Score label", choices=score_label_choices, value="all")
+                text_query = gr.Textbox(label="Issuer or sector search")
+            explore_df = gr.Dataframe(value=events.head(100), interactive=False)
+            def _update_events(member_query: str, event_type: str, score_label: str, text_query: str):
+                return _filter_events(events, member_query, event_type, score_label, text_query)
+            for control in (member_query, event_type, score_label, text_query):
+                control.change(_update_events, [member_query, event_type, score_label, text_query], explore_df)
+        with gr.Tab("Network Graph"):
+            gr.Markdown(_graph_intro_markdown(data["graph_config"]))
+            with gr.Row():
+                family = gr.Dropdown(label="Relationship view", choices=graph_family_choices, value=str(graph_defaults.get("relationship_family", "sector")))
+                member_graph_query = gr.Textbox(label="Member name or slug")
+                target_query = gr.Textbox(label="Recipient or sector search")
+                graph_score = gr.Dropdown(label="Score label", choices=graph_score_choices, value="all")
+                review_status = gr.Dropdown(label="Relationship strength", choices=graph_status_choices, value=str(graph_defaults.get("review_status", "stronger")))
+            with gr.Row():
+                hide_unresolved_only = gr.Checkbox(label="Hide unresolved relationships", value=bool(graph_defaults.get("hide_unresolved_only", True)))
+                max_edges = gr.Slider(label="Max visible relationships", minimum=25, maximum=300, step=25, value=int(graph_defaults.get("max_edges", 60)))
+            graph_html = gr.HTML()
+            graph_df = gr.Dataframe(interactive=False)
+            def _update_graph(family: str, member_graph_query: str, target_query: str, graph_score: str, review_status: str, hide_unresolved_only: bool, max_edges: int):
+                filtered_edges = _filter_graph(edges, family, member_graph_query, target_query, graph_score, review_status, hide_unresolved_only, max_edges, overview_member_limit)
+                filtered_nodes = nodes[nodes["node_id"].isin(set(filtered_edges["source_node_id"]).union(set(filtered_edges["target_node_id"])))]
+                return _render_graph(filtered_nodes, filtered_edges), filtered_edges
+            for control in (family, member_graph_query, target_query, graph_score, review_status, hide_unresolved_only, max_edges):
+                control.change(_update_graph, [family, member_graph_query, target_query, graph_score, review_status, hide_unresolved_only, max_edges], [graph_html, graph_df])
+            app.load(_update_graph, [family, member_graph_query, target_query, graph_score, review_status, hide_unresolved_only, max_edges], [graph_html, graph_df])
+        with gr.Tab("Event Detail"):
+            event_id = gr.Dropdown(label="Event id", choices=event_id_choices, value=event_id_choices[0] if event_id_choices else None)
+            event_detail_md = gr.Markdown()
+            event_detail_df = gr.Dataframe(interactive=False)
+            event_id.change(_event_detail, [gr.State(events), gr.State(provenance), event_id], [event_detail_md, event_detail_df])
+            app.load(_event_detail, [gr.State(events), gr.State(provenance), event_id], [event_detail_md, event_detail_df])
+        with gr.Tab("Audit"):
+            gr.Markdown(_consistency_summary_markdown(data["consistency"]))
+            gr.Dataframe(value=data["artifact_index"].head(200), interactive=False)
+        with gr.Tab("Methodology & Limits"):
+            gr.Markdown(copy_payload.get("landing_markdown", ""))
+            gr.Markdown(copy_payload.get("downloads_markdown", ""))
+        with gr.Tab("Downloads"):
+            gr.Markdown(copy_payload.get("downloads_markdown", ""))
+    return app

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.44.0
+pandas>=2.2.0
+pyvis>=0.3.2