Update app.py

app.py

@@ -1,239 +1,233 @@
+import gradio as gr
 import time
+import re
 from typing import List, Dict
 
-import gradio as gr
+###############################################################################
+# GLOBAL STATE (HF SAFE)
+###############################################################################
 
-from ingest.registry import (
-    get_all_adapters,
-    BASE_AGENCIES,
-    EXTENDED_AGENCIES,
-)
-from citations import cite
-import coverage
-import saved_searches
-
-
-# ======================================================
-# Adapter Registry
-# ======================================================
-
-ALL_ADAPTERS = get_all_adapters()
-
-
-# ======================================================
-# Async Federated Search Engine
-# ======================================================
-
-async def _search_adapter(adapter, query: str) -> Dict:
-    start = time.time()
-    try:
-        results = await adapter.search(query)
-        latency = round(time.time() - start, 2)
-        return {
-            "ok": True,
-            "results": results,
-            "latency": latency,
-            "source": adapter.source_name,
-        }
-    except Exception as e:
-        return {
-            "ok": False,
-            "results": [],
-            "latency": None,
-            "source": adapter.source_name,
-            "error": str(e),
-        }
-
-
-async def federated_search_async(
-    query: str,
-    enabled_agencies: List[str],
-):
-    adapters = [
-        ALL_ADAPTERS[a]
-        for a in enabled_agencies
-        if a in ALL_ADAPTERS
-    ]
+RESULT_CACHE: List[Dict] = []
+SELECTED_INDEX = 0
 
-    tasks = [_search_adapter(a, query) for a in adapters]
-    responses = await gradio_async_gather(tasks)
+###############################################################################
+# UTILITIES
+###############################################################################
 
-    flat_results = []
-    health = {}
+def highlight(text: str, query: str) -> str:
+    if not query:
+        return text
+    terms = [re.escape(t) for t in query.split() if len(t) > 1]
+    if not terms:
+        return text
+    pattern = re.compile(rf"({'|'.join(terms)})", re.IGNORECASE)
+    return pattern.sub(r"<mark>\1</mark>", text)
 
-    for r in responses:
-        health[r["source"]] = {
-            "ok": r["ok"],
-            "latency": r["latency"],
-        }
-        if r["ok"]:
-            flat_results.extend(r["results"])
 
-    return flat_results, health
+def redaction_score(text: str) -> float:
+    """
+    Heuristic confidence score that document may contain redactions.
+    0.0 = none detected, 1.0 = heavy redaction likelihood
+    """
+    hits = sum(
+        k in text.lower()
+        for k in ["redact", "b(1)", "b(3)", "withheld", "classified"]
+    )
+    return round(min(1.0, hits * 0.25), 2)
 
 
-async def gradio_async_gather(tasks):
+def badge(r: Dict) -> str:
+    live = "🟢 LIVE" if r["live"] else "🟡 STUB"
+    return f"`{live}` · `{r['agency']}`"
+
+
+###############################################################################
+# MOCK ADAPTER OUTPUT (REPLACE WITH REAL ADAPTERS)
+###############################################################################
+
+def run_federated_query(query: str) -> List[Dict]:
     """
-    HF-safe async gather wrapper.
+    HF-safe simulated adapter aggregation.
     """
-    import asyncio
-    return await asyncio.gather(*tasks, return_exceptions=False)
+    time.sleep(0.4)
+
+    return [
+        {
+            "title": "UAP Task Force Report (Preliminary)",
+            "snippet": "The UAPTF evaluated a number of UAP incidents...",
+            "url": "https://www.dni.gov/files/ODNI/documents/assessments/Prelimary-Assessments-UAP-20210625.pdf",
+            "agency": "ODNI",
+            "source": "ODNI FOIA Reading Room",
+            "live": True,
+        },
+        {
+            "title": "CIA Memorandum on Aerial Phenomena",
+            "snippet": "This document was partially redacted under b(3)...",
+            "url": "https://www.cia.gov/readingroom/docs/DOC_000001.pdf",
+            "agency": "CIA",
+            "source": "CIA FOIA Reading Room",
+            "live": True,
+        },
+        {
+            "title": "Project BLUE BOOK Summary",
+            "snippet": "Historical summary of investigations into unidentified objects...",
+            "url": "https://www.archives.gov/research/military/air-force/ufos",
+            "agency": "USAF",
+            "source": "National Archives",
+            "live": False,
+        },
+    ]
+
 
+###############################################################################
+# RESULT RENDERING
+###############################################################################
 
-# ======================================================
-# Rendering Helpers
-# ======================================================
+def agency_counts(results: List[Dict]) -> str:
+    counts = {}
+    for r in results:
+        counts[r["agency"]] = counts.get(r["agency"], 0) + 1
 
-def badge(result: Dict) -> str:
-    badges = []
-    badges.append("🟢 LIVE" if result.get("live") else "🟡 STUB")
-    if result.get("extended"):
-        badges.append("⚠️ EXTENDED")
-    return " · ".join(badges)
+    lines = ["### 🏛️ Per-Agency Coverage"]
+    for agency, count in sorted(counts.items()):
+        lines.append(f"- **{agency}**: {count}")
 
+    return "\n".join(lines)
 
-def render_result(r: Dict) -> str:
-    return f"""
-### {r['title']}
-**{r['source']} · {badge(r)}**
 
-{r['snippet']}
+def render_results(results: List[Dict], query: str) -> str:
+    lines = ["### 📚 Search Results (click to preview)\n"]
 
-🔗 {r['url']}
+    for i, r in enumerate(results):
+        title = highlight(r["title"], query)
+        snippet = highlight(r["snippet"], query)
+        score = redaction_score(r["snippet"])
 
-<details>
-<summary>📑 Citation</summary>
+        lines.append(
+            f"""
+<div style="cursor:pointer" onclick="">
+**{i+1}. {title}**  
+{badge(r)}  
+🛡️ Redaction Confidence: **{score}**
 
-{cite(r)}
+{snippet}
 
-</details>
+🔗 [Open Source]({r['url']})
+</div>
 """
+        )
 
+    return "\n\n---\n\n".join(lines)
 
-def render_health(health: Dict) -> str:
-    lines = ["### 🩺 Agency Health\n"]
-    for agency, h in health.items():
-        if h["ok"]:
-            lines.append(f"- **{agency}**: 🟢 {h['latency']}s")
-        else:
-            lines.append(f"- **{agency}**: 🔴 unavailable")
-    return "\n".join(lines)
 
+###############################################################################
+# PREVIEW PANEL
+###############################################################################
+
+def render_preview(index: int) -> str:
+    if not RESULT_CACHE:
+        return "_No document selected._"
+
+    index = max(0, min(index, len(RESULT_CACHE) - 1))
+    r = RESULT_CACHE[index]
+
+    score = redaction_score(r["snippet"])
+
+    header = f"""
+### 📄 Document Preview ({index + 1}/{len(RESULT_CACHE)})
+**{r['title']}**  
+{r['source']} · `{r['agency']}`  
+🛡️ Redaction Confidence: **{score}**
+"""
+
+    iframe = f"""
+<iframe src="{r['url']}" width="100%" height="550px"
+style="border:1px solid #444;border-radius:8px;"></iframe>
+"""
+
+    return header + iframe
 
-# ======================================================
-# HF-SAFE ASYNC SEARCH HANDLER
-# ======================================================
 
-async def run_search(
-    query: str,
-    hide_stubs: bool,
-    enable_extended: bool,
-    enabled_extended_agencies: List[str],
-):
+###############################################################################
+# SEARCH HANDLER
+###############################################################################
+
+def run_search(query: str):
+    global RESULT_CACHE, SELECTED_INDEX
+
     if not query.strip():
-        return "Enter a search term.", "", ""
+        return "⚠️ Enter a search term.", "_", "_"
 
-    agencies = list(BASE_AGENCIES)
+    results = run_federated_query(query)
 
-    if enable_extended:
-        agencies.extend(
-            [a for a in enabled_extended_agencies if a in EXTENDED_AGENCIES]
-        )
+    RESULT_CACHE = results
+    SELECTED_INDEX = 0
 
-    results, health = await federated_search_async(query, agencies)
+    return (
+        render_results(results, query),
+        render_preview(0),
+        agency_counts(results),
+    )
 
-    saved_searches.save(query, enable_extended)
 
-    if hide_stubs:
-        results = [r for r in results if r.get("live")]
+def next_doc(idx):
+    idx = min(idx + 1, len(RESULT_CACHE) - 1)
+    return render_preview(idx), idx
 
-    if not results:
-        return "No results found.", render_health(health), coverage.render_coverage()
 
-    rendered = "\n\n---\n\n".join(render_result(r) for r in results)
-    return rendered, render_health(health), coverage.render_coverage()
+def prev_doc(idx):
+    idx = max(idx - 1, 0)
+    return render_preview(idx), idx
 
 
-# ======================================================
-# Gradio UI
-# ======================================================
+###############################################################################
+# UI
+###############################################################################
 
-with gr.Blocks(title="Federated FOIA Document Search") as demo:
+with gr.Blocks(theme=gr.themes.Soft()) as app:
     gr.Markdown(
         """
 # 🏛️ Federated FOIA Document Search
-
-Search **public government FOIA electronic reading rooms** across multiple agencies.
-
-- **Default:** Safe, public-only sources  
-- **Extended mode:** Additional public releases (opt-in)  
-- No authentication  
-- No classified or restricted systems  
+Search public FOIA reading rooms across agencies.
 """
     )
 
-    query = gr.Textbox(
-        label="Search term",
-        placeholder="e.g. UAP, radar incident, AATIP",
-    )
+    query = gr.Textbox(label="Search term", placeholder="e.g. UAP")
 
-    with gr.Row():
-        hide_stubs = gr.Checkbox(
-            label="Hide stub (non-live) sources",
-            value=False,
-        )
-        enable_extended = gr.Checkbox(
-            label="Enable Extended Features (live but sensitive public sources)",
-            value=False,
-        )
+    search_btn = gr.Button("🔍 Search")
 
-    with gr.Accordion("Extended Agency Kill Switches", open=False):
-        extended_agencies = gr.CheckboxGroup(
-            choices=EXTENDED_AGENCIES,
-            label="Enable specific extended agencies",
-        )
+    selected_index = gr.State(0)
 
-    search_btn = gr.Button("🔍 Search")
+    with gr.Row():
+        with gr.Column(scale=5):
+            results_md = gr.Markdown()
+
+        with gr.Column(scale=7):
+            preview_md = gr.Markdown()
+            with gr.Row():
+                prev_btn = gr.Button("⬅️ Previous")
+                next_btn = gr.Button("➡️ Next")
 
-    results_md = gr.Markdown()
-    health_md = gr.Markdown()
     coverage_md = gr.Markdown()
 
     search_btn.click(
         fn=run_search,
-        inputs=[
-            query,
-            hide_stubs,
-            enable_extended,
-            extended_agencies,
-        ],
-        outputs=[
-            results_md,
-            health_md,
-            coverage_md,
-        ],
+        inputs=query,
+        outputs=[results_md, preview_md, coverage_md],
     )
 
-    with gr.Accordion("Saved Searches", open=False):
-        gr.Markdown(saved_searches.render())
-
-    with gr.Accordion("About & Legal", open=False):
-        gr.Markdown(
-            """
-**Legal Notice**
-
-This tool:
-- Accesses **only publicly available FOIA electronic reading rooms**
-- Respects robots.txt and rate limits
-- Does not bypass access controls
-- Is intended for journalism, research, and public-interest use
-"""
-        )
+    prev_btn.click(
+        fn=prev_doc,
+        inputs=selected_index,
+        outputs=[preview_md, selected_index],
+    )
 
+    next_btn.click(
+        fn=next_doc,
+        inputs=selected_index,
+        outputs=[preview_md, selected_index],
+    )
 
-# ======================================================
-# HF ENTRY POINT
-# ======================================================
 
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()