Update app.py

app.py

@@ -1,131 +1,116 @@
-# Federal FOIA Intelligence Search
-# Public Electronic Reading Rooms Only
+"""
+Federal FOIA Intelligence Search
+Public Electronic Reading Rooms Only
+HF Spaces compatible (no asyncio.run)
+"""
 
-import gradio as gr
 import time
-from collections import defaultdict
+import asyncio
+import gradio as gr
 from typing import List, Dict
+from ingest.registry import get_enabled_adapters
+from ingest.health import get_health_snapshot
+from ingest.cluster import semantic_cluster
+from ingest.export import export_zip
+from ingest.utils import highlight_terms
 
-from ingest.registry import get_all_adapters
-from analytics.semantic import semantic_cluster
-from analytics.health import adapter_health
-from analytics.foia_bcodes import classify_b_codes
-from exports.journalist_zip import build_zip
-from ui.heatmap import render_heatmap
-
-APP_TITLE = "Federal FOIA Intelligence Search"
+TITLE = "🏛️ Federal FOIA Intelligence Search"
 SUBTITLE = "Public Electronic Reading Rooms Only"
 
-ALL_ADAPTERS = get_all_adapters()
+# ---------- Async-safe search wrapper ----------
 
+async def run_search(query: str, enable_live: bool, hide_stub: bool):
+    adapters = get_enabled_adapters(enable_live=enable_live)
+    results = []
+    per_agency_counts = {}
 
-def run_search(query: str, include_stubs: bool, extended: bool):
-    start = time.time()
+    tasks = []
+    for adapter in adapters:
+        tasks.append(adapter.search(query))
 
-    results = []
-    per_agency_counts = defaultdict(int)
-    health = {}
+    responses = await asyncio.gather(*tasks, return_exceptions=True)
 
-    for name, adapter in ALL_ADAPTERS.items():
-        if adapter.is_stub and not include_stubs:
-            continue
-        if adapter.extended and not extended:
+    for adapter, response in zip(adapters, responses):
+        if isinstance(response, Exception):
             continue
-        if adapter.killed:
+        if hide_stub and adapter.is_stub:
             continue
+        per_agency_counts[adapter.source_name] = len(response)
+        for r in response:
+            r["source"] = adapter.source_name
+            r["latency"] = adapter.last_latency
+            results.append(r)
+
+    clustered = semantic_cluster(results)
+    return results, clustered, per_agency_counts
+
+
+def search_ui(query, enable_live, hide_stub):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    results, clusters, counts = loop.run_until_complete(
+        run_search(query, enable_live, hide_stub)
+    )
+
+    table = []
+    for r in results:
+        table.append([
+            r["source"],
+            highlight_terms(r["title"], query),
+            r["url"],
+            r.get("snippet", ""),
+            f"{r.get('latency', 0):.2f}s"
+        ])
+
+    return table, clusters, counts
+
+
+# ---------- UI ----------
+
+with gr.Blocks(title="Federal FOIA Intelligence Search") as demo:
+    gr.Markdown(f"# {TITLE}")
+    gr.Markdown(f"### {SUBTITLE}")
 
-        try:
-            t0 = time.time()
-            docs = adapter.search_sync(query)
-            latency = time.time() - t0
-            health[name] = adapter_health(latency)
-            for d in docs:
-                d["agency"] = name
-                d["b_codes"] = classify_b_codes(d)
-                results.append(d)
-                per_agency_counts[name] += 1
-        except Exception as e:
-            health[name] = {"status": "error", "detail": str(e)}
-
-    clusters = semantic_cluster(results)
-    elapsed = round(time.time() - start, 2)
-
-    return {
-        "results": results,
-        "clusters": clusters,
-        "counts": dict(per_agency_counts),
-        "health": health,
-        "elapsed": elapsed,
-    }
-
-
-def render_results(state):
-    md = []
-    for r in state["results"]:
-        badge = f"⚖️ {','.join(r['b_codes'])}" if r["b_codes"] else ""
-        md.append(
-            f"### [{r['title']}]({r['url']})\n"
-            f"*{r['agency']}* {badge}\n\n"
-            f"{r['snippet']}\n"
-        )
-    return "\n---\n".join(md)
-
-
-with gr.Blocks(title=APP_TITLE) as demo:
-    gr.Markdown(f"# 🏛️ {APP_TITLE}\n### *{SUBTITLE}*")
     gr.Markdown(
-        "Federated discovery across **lawfully published U.S. Government FOIA Electronic Reading Rooms**.\n\n"
-        "### Safeguards\n"
-        "- Public documents only\n"
-        "- Robots.txt enforced\n"
-        "- No restricted systems\n"
-        "- No classified access\n"
-        "- Per-agency kill switches\n"
+        "**Terms of Use:** This tool indexes only documents already released "
+        "to the public via official FOIA Electronic Reading Rooms."
     )
 
-    query = gr.Textbox(label="Search FOIA Reading Rooms", placeholder="UAP")
-    include_stubs = gr.Checkbox(True, label="Include Stub Sources (Coverage Only)")
-    extended = gr.Checkbox(False, label="Enable Extended Features (Live Intelligence-Related Rooms)")
+    with gr.Row():
+        query = gr.Textbox(label="Search FOIA documents")
+        search_btn = gr.Button("Search")
+
+    with gr.Row():
+        enable_live = gr.Checkbox(label="Enable Live Public Adapters", value=False)
+        hide_stub = gr.Checkbox(label="Hide Stub Sources", value=True)
 
-    search_btn = gr.Button("Search")
+    results_table = gr.Dataframe(
+        headers=["Agency", "Title", "URL", "Snippet", "Latency"],
+        interactive=False,
+        wrap=True
+    )
 
-    results_md = gr.Markdown()
-    heatmap = gr.HTML()
-    latency_md = gr.Markdown()
-    cluster_md = gr.Markdown()
-    export_btn = gr.Button("🧾 Export Selected to ZIP")
+    clusters_box = gr.JSON(label="Semantic Clusters (Explainable)")
+    counts_box = gr.JSON(label="Per-Agency Result Counts")
 
-    state = gr.State()
+    health_box = gr.JSON(
+        value=get_health_snapshot(),
+        label="Agency Health / Latency"
+    )
 
-    def on_search(q, s, e):
-        state_val = run_search(q, s, e)
-        return (
-            state_val,
-            render_results(state_val),
-            render_heatmap(state_val["counts"]),
-            f"⏱️ Completed in {state_val['elapsed']}s",
-            f"🧠 Clusters: {len(state_val['clusters'])}",
-        )
+    export_btn = gr.Button("Export Selected → Journalist ZIP")
+    export_status = gr.Textbox(label="Export Status")
 
     search_btn.click(
-        on_search,
-        inputs=[query, include_stubs, extended],
-        outputs=[state, results_md, heatmap, latency_md, cluster_md],
+        fn=search_ui,
+        inputs=[query, enable_live, hide_stub],
+        outputs=[results_table, clusters_box, counts_box]
     )
 
     export_btn.click(
-        lambda s: build_zip(s["results"]),
-        inputs=[state],
-        outputs=[],
-    )
-
-    gr.Markdown(
-        "## ⚖️ Legal & Ethical Notice\n"
-        "This system indexes **only documents already released to the public** under FOIA.\n\n"
-        "**It does not:**\n"
-        "- Circumvent access controls\n"
-        "- Access classified systems\n"
-        "- Declassify or infer restricted information\n"
+        fn=export_zip,
+        inputs=[results_table],
+        outputs=[export_status]
     )
 
-demo.launch()
+demo.queue().launch()