Update app.py

app.py

@@ -1,53 +1,28 @@
-# app.py — AEGIS FactCheck (Gradio + Futuristic Theme)
+# app.py — AEGIS FactCheck (SLIM, guarded imports, no NLTK)
 from __future__ import annotations
-import os, json, re, time, glob, uuid, shutil, subprocess, urllib.parse
+import os, re, json, time, glob, uuid, shutil, subprocess, urllib.parse
 from typing import List, Dict, Optional
 from datetime import datetime, timezone
 
 import numpy as np
 import pandas as pd
 import requests
-
-import nltk
-from nltk.tokenize import sent_tokenize
-nltk.download('punkt', quiet=True)
-
-
-from rank_bm25 import BM25Okapi
-from sentence_transformers import SentenceTransformer, util
-from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
-
-from duckduckgo_search import DDGS
-import trafilatura
-
-# OCR / ASR
-import easyocr, cv2, whisper
-
 import gradio as gr
 
-# ===================== Config =====================
-FORCE_BASELINE = True   # set False to allow OpenAI LLM path (if OPENAI_API_KEY set)
-USE_WEB_DEFAULT = True
-USE_WIKI_DEFAULT = True
-
-try:
-    from nltk.tokenize import sent_tokenize  # optional, if nltk happens to be installed
-except Exception:
-    def sent_tokenize(txt: str):
-        import re
-        # simple rule-based splitter
-        return [s.strip() for s in re.split(r'(?<=[.!?])\s+|\n+', txt or '') if s.strip()]
-        
-try:
-    import openai
-    _has_key = True if os.environ.get("OPENAI_API_KEY") else False
-except Exception:
-    _has_key = False
+# ---------- lightweight helpers ----------
+def now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
 
-def has_llm() -> bool:
-    return (not FORCE_BASELINE) and _has_key
+def normalize_ws(s: str) -> str:
+    return re.sub(r"\s+", " ", s or "").strip()
 
-def now_iso(): return datetime.now(timezone.utc).isoformat()
+def sent_tokenize_fallback(txt: str) -> List[str]:
+    # NLTK-free sentence splitter
+    return [s.strip() for s in re.split(r'(?<=[.!?])\s+|\n+', txt or '') if s.strip()]
+
+def domain_from_url(url: str) -> str:
+    try: return urllib.parse.urlparse(url).netloc.lower()
+    except Exception: return ""
 
 USER_AGENT = "DisinfoFactcheck/1.0 (contact: [email protected])"
 HEADERS = {"User-Agent": USER_AGENT}
@@ -61,19 +36,37 @@ DEFAULT_ALLOWLIST = [
     "nature.com","sciencemag.org","thelancet.com","nejm.org",
 ]
 
-# ===================== Helpers =====================
-REPORTING_PREFIXES = re.compile(r'^(from a video:|another line says:|it also claims:|the video says:|the speaker claims:|someone said:)', re.I)
-STOP = {"the","a","an","from","it","also","claims","claim","says","said","line","video","across","cities","that","this","these","those","is","are","was","were","has","have","had","will","can","does","did"}
+FORCE_BASELINE = True   # leave True; OpenAI LLM path is optional and guarded
 
-def normalize_ws(s: str) -> str:
-    return re.sub(r"\s+", " ", s or "").strip()
+# ---------- optional imports (guarded) ----------
+def _try_import(name: str):
+    try:
+        return __import__(name)
+    except Exception:
+        return None
 
-def domain_from_url(url: str) -> str:
-    try: return urllib.parse.urlparse(url).netloc.lower()
-    except Exception: return ""
+duckduckgo_search = _try_import("duckduckgo_search")
+trafilatura = _try_import("trafilatura")
+rank_bm25 = _try_import("rank_bm25")
+sentence_transformers = _try_import("sentence_transformers")
+transformers = _try_import("transformers")
+torch = _try_import("torch")
+
+# Heavy CV/ASR guarded
+cv2 = _try_import("cv2")
+easyocr = _try_import("easyocr")
+whisper = _try_import("whisper")
+
+# OpenAI is optional
+_openai = _try_import("openai")
+_has_openai_key = bool(os.environ.get("OPENAI_API_KEY"))
+
+def has_llm() -> bool:
+    return (not FORCE_BASELINE) and _openai is not None and _has_openai_key
 
-def split_into_chunks(text: str, max_chars: int = 700):
-    sents = [normalize_ws(s) for s in sent_tokenize(text or "")]
+# ---------- text splitting ----------
+def split_into_chunks(text: str, max_chars: int = 700) -> List[str]:
+    sents = [normalize_ws(s) for s in sent_tokenize_fallback(text or "")]
     chunks, cur = [], ""
     for s in sents:
         if len(cur) + 1 + len(s) > max_chars and cur:
@@ -83,8 +76,7 @@ def split_into_chunks(text: str, max_chars: int = 700):
     if cur: chunks.append(cur.strip())
     return [c for c in chunks if len(c) > 40]
 
-
-# ===================== Wikipedia =====================
+# ---------- Wikipedia ----------
 WIKI_API = "https://en.wikipedia.org/w/api.php"
 
 def wiki_search(query: str, n: int = 6) -> List[Dict]:
@@ -102,6 +94,9 @@ def wiki_page_content(pageid: int) -> Dict:
     return {"pageid": page.get("pageid"), "title": page.get("title"), "url": page.get("fullurl"),
             "last_modified": (page.get("revisions") or [{}])[0].get("timestamp"), "text": page.get("extract") or ""}
 
+REPORTING_PREFIXES = re.compile(r'^(from a video:|another line says:|it also claims:|the video says:|the speaker claims:|someone said:)', re.I)
+STOP = {"the","a","an","from","it","also","claims","claim","says","said","line","video","across","cities","that","this","these","those","is","are","was","were","has","have","had","will","can","does","did"}
+
 def sanitize_claim_for_search(s: str) -> str:
     s = REPORTING_PREFIXES.sub('', (s or "").strip()).strip('"\'' )
     s = re.sub(r"[^A-Za-z0-9\s-]", " ", s)
@@ -112,11 +107,10 @@ def keywords_only(s: str, limit: int = 10) -> str:
     return " ".join(toks[:limit]) or s
 
 def heuristic_rewrites(s: str) -> List[str]:
-    rewrites = [s]
+    rewrites = [s, s + " misinformation"]
     rewrites.append(re.sub(r"5g[^\w]+.*covid[- ]?19", "5G COVID-19 conspiracy", s, flags=re.I))
     rewrites.append(re.sub(r"owns?\s+the\s+world\s+health\s+organization", "Bill Gates WHO relationship", s, flags=re.I))
     rewrites.append(re.sub(r"nasa[^\w]+.*darkness", "NASA hoax darkness", s, flags=re.I))
-    rewrites.append(s + " misinformation")
     return list(dict.fromkeys([sanitize_claim_for_search(x) for x in rewrites]))
 
 def build_wiki_corpus(claim: str, max_pages: int = 6, chunk_chars: int = 600) -> List[Dict]:
@@ -137,8 +131,11 @@ def build_wiki_corpus(claim: str, max_pages: int = 6, chunk_chars: int = 600) ->
         if len(corpus) >= max_pages * 2: break
     return list({d["id"]: d for d in corpus}.values())
 
-# ===================== Web retrieval =====================
+# ---------- Web retrieval ----------
 def ddg_search(query: str, max_results: int = 10, allowlist: Optional[List[str]] = None) -> List[Dict]:
+    if duckduckgo_search is None:
+        return []
+    DDGS = duckduckgo_search.DDGS
     allowlist = allowlist or DEFAULT_ALLOWLIST
     out = []
     with DDGS() as ddgs:
@@ -149,6 +146,14 @@ def ddg_search(query: str, max_results: int = 10, allowlist: Optional[List[str]]
     return out
 
 def fetch_clean_text(url: str) -> str:
+    if trafilatura is None:  # degrade
+        try:
+            # last-chance plain GET (messy but better than nothing)
+            r = requests.get(url, headers=HEADERS, timeout=12); r.raise_for_status()
+            txt = re.sub(r"<[^>]+>", " ", r.text)
+            return normalize_ws(txt)[:8000]
+        except Exception:
+            return ""
     try:
         downloaded = trafilatura.fetch_url(url)
         if not downloaded: return ""
@@ -172,22 +177,11 @@ def build_web_corpus(claim: str, allowlist: Optional[List[str]] = None, per_quer
             for j, ch in enumerate(split_into_chunks(text, max_chars=chunk_chars)):
                 corpus.append({"id": f"web-{hash(url)}-{j}", "source":"web", "title": h["title"] or domain_from_url(url),
                                "url": url, "published": now_iso(), "text": ch})
-        time.sleep(0.8)
+        time.sleep(0.6)  # polite
         if len(corpus) >= per_query_results * 4: break
     return list({d["id"]: d for d in corpus}.values())
 
-# ===================== Retrieval + Verification =====================
-def filter_by_time(docs: List[Dict], t_max_iso: str) -> List[Dict]:
-    tmax = datetime.fromisoformat(t_max_iso.replace("Z","+00:00"))
-    kept = []
-    for d in docs:
-        try:
-            dt = datetime.fromisoformat(d["published"].replace("Z","+00:00"))
-            if dt <= tmax: kept.append(d)
-        except Exception:
-            kept.append(d)
-    return kept
-
+# ---------- retrieval scoring (BM25 + optional dense) ----------
 def tokenize_simple(text: str) -> List[str]:
     text = re.sub(r"[^a-z0-9\s]", " ", (text or "").lower())
     return [w for w in text.split() if w and w not in {"the","a","an","and","or","of","to","in","for","on","with"}]
@@ -199,36 +193,116 @@ def rrf_merge(orderings: List[List[str]], k: int = 60) -> List[str]:
             scores[doc_id] = scores.get(doc_id, 0.0) + 1.0/(k + r)
     return [doc for doc,_ in sorted(scores.items(), key=lambda x: -x[1])]
 
-EMB_NAME = "sentence-transformers/multi-qa-MiniLM-L6-cos-v1"
-emb_model = SentenceTransformer(EMB_NAME)
+# try to load BM25
+BM25Okapi = getattr(rank_bm25, "BM25Okapi", None) if rank_bm25 else None
+
+# try to prepare sentence-transformers
+_emb_model = None
+if sentence_transformers:
+    try:
+        _emb_model = sentence_transformers.SentenceTransformer("sentence-transformers/multi-qa-MiniLM-L6-cos-v1")
+        from sentence_transformers import util as st_util
+    except Exception:
+        _emb_model = None
+        st_util = None
+else:
+    st_util = None
 
 def retrieve_hybrid(claim: str, docs: List[Dict], k: int = 8) -> List[Dict]:
     if not docs: return []
-    corpus_tokens = [tokenize_simple(d["text"]) for d in docs]
-    bm25 = BM25Okapi(corpus_tokens)
-    bm25_scores = bm25.get_scores(tokenize_simple(claim))
-    bm25_order = [docs[i]["id"] for i in list(np.argsort(-np.array(bm25_scores)))]
-    q_emb = emb_model.encode([claim], convert_to_tensor=True, show_progress_bar=False)
-    d_emb = emb_model.encode([d["text"] for d in docs], convert_to_tensor=True, show_progress_bar=False)
-    sims = util.cos_sim(q_emb, d_emb).cpu().numpy().ravel()
-    dense_order = [docs[i]["id"] for i in list(np.argsort(-sims))]
-    ordering = rrf_merge([bm25_order, dense_order], k=60)
+    # BM25 (always available? If not, fall back to keyword cosine)
+    bm25_order = []
+    if BM25Okapi:
+        corpus_tokens = [tokenize_simple(d["text"]) for d in docs]
+        bm25 = BM25Okapi(corpus_tokens)
+        bm25_scores = bm25.get_scores(tokenize_simple(claim))
+        bm25_order = [docs[i]["id"] for i in list(np.argsort(-np.array(bm25_scores)))]
+    else:
+        # poor-man BM25: sort by overlap count
+        q_toks = set(tokenize_simple(claim))
+        overlaps = [(i, len(q_toks.intersection(set(tokenize_simple(d["text"]))))) for i, d in enumerate(docs)]
+        bm25_order = [docs[i]["id"] for i,_ in sorted(overlaps, key=lambda x: -x[1])]
+
+    # Dense (optional)
+    dense_order = []
+    if _emb_model and st_util:
+        try:
+            q_emb = _emb_model.encode([claim], convert_to_tensor=True, show_progress_bar=False)
+            d_emb = _emb_model.encode([d["text"] for d in docs], convert_to_tensor=True, show_progress_bar=False)
+            sims = st_util.cos_sim(q_emb, d_emb).cpu().numpy().ravel()
+            dense_order = [docs[i]["id"] for i in list(np.argsort(-sims))]
+        except Exception:
+            dense_order = bm25_order
+
+    ordering = rrf_merge([bm25_order, dense_order or bm25_order], k=60)
     top_ids = set(ordering[:max(k, 14)])
     id2doc = {d["id"]: d for d in docs}
     ranked_docs = [id2doc[i] for i in ordering if i in top_ids]
     return [{**doc, "score": float(1/(60+i))} for i, doc in enumerate(ranked_docs[:k])]
 
-VERIFIER_PROMPT = '''
-You are a fact verification model. Use ONLY the EVIDENCE provided.
-Return STRICT JSON with keys: label, used_evidence_ids, confidence, rationale (<=60 words).
-label in {SUPPORT, REFUTE, NEI}. Do not guess if evidence is insufficient.
+# ---------- verifier (transformers optional; heuristic fallback) ----------
+_nli_pipeline = None
+if transformers:
+    try:
+        AutoModelForSequenceClassification = transformers.AutoModelForSequenceClassification
+        AutoTokenizer = transformers.AutoTokenizer
+        _nli_tok = AutoTokenizer.from_pretrained("roberta-large-mnli")
+        _nli_model = AutoModelForSequenceClassification.from_pretrained("roberta-large-mnli")
+        _nli_pipeline = transformers.pipeline("text-classification", model=_nli_model, tokenizer=_nli_tok,
+                                              return_all_scores=True, truncation=True, device=-1)
+    except Exception:
+        _nli_pipeline = None
 
-CLAIM:
-{claim}
+def verify_with_nli(claim: str, evidence: List[Dict]) -> Dict:
+    # If NLI pipeline available
+    if _nli_pipeline:
+        best_ent_id, best_ent_p = None, 0.0
+        best_con_id, best_con_p = None, 0.0
+        for e in evidence or []:
+            prem = (e.get("text") or "").strip()
+            if not prem: continue
+            outputs = _nli_pipeline([{"text": prem, "text_pair": claim}])
+            probs = {d["label"].upper(): float(d["score"]) for d in outputs[0]}
+            ent, con = probs.get("ENTAILMENT", 0.0), probs.get("CONTRADICTION", 0.0)
+            if ent > best_ent_p: best_ent_id, best_ent_p = e.get("id"), ent
+            if con > best_con_p: best_con_id, best_con_p = e.get("id"), con
+        label, used = "NEI", []
+        conf = max(0.34, float(best_ent_p*0.5 + (1-best_con_p)*0.25))
+        rationale = "Insufficient or inconclusive evidence."
+        if best_ent_p >= 0.60 and (best_ent_p - best_con_p) >= 0.10:
+            label, used, conf, rationale = "SUPPORT", [best_ent_id] if best_ent_id else [], best_ent_p, "Top evidence entails the claim."
+        elif best_con_p >= 0.60 and (best_con_p - best_ent_p) >= 0.10:
+            label, used, conf, rationale = "REFUTE", [best_con_id] if best_con_id else [], best_con_p, "Top evidence contradicts the claim."
+        return {"label": label, "used_evidence_ids": used, "confidence": float(conf), "rationale": rationale}
+
+    # Heuristic fallback (no transformers)
+    text = " ".join((e.get("text") or "")[:400].lower() for e in evidence[:6])
+    k = sanitize_claim_for_search(claim).lower()
+    if any(x in text for x in ["false", "hoax", "debunked", "misinformation", "no evidence", "not true"]) and any(y in text for y in k.split()[:4]):
+        return {"label": "REFUTE", "used_evidence_ids": [evidence[0]["id"]] if evidence else [], "confidence": 0.6, "rationale": "Heuristic: evidence indicates refutation keywords."}
+    if any(x in text for x in ["confirmed", "approved", "verified", "evidence shows", "found that"]) and any(y in text for y in k.split()[:4]):
+        return {"label": "SUPPORT", "used_evidence_ids": [evidence[0]["id"]] if evidence else [], "confidence": 0.55, "rationale": "Heuristic: evidence indicates support keywords."}
+    return {"label": "NEI", "used_evidence_ids": [], "confidence": 0.4, "rationale": "Insufficient signal without NLI."}
 
-EVIDENCE (id, date, source, text):
-{evidence_block}
-'''
+def enforce_json_schema(x: Dict) -> Dict:
+    return {"label": str(x.get("label","NEI")).upper(),
+            "used_evidence_ids": [str(i) for i in x.get("used_evidence_ids", []) if i],
+            "confidence": float(x.get("confidence", 0.5)),
+            "rationale": str(x.get("rationale","")).strip()[:300]}
+
+def filter_by_time(docs: List[Dict], t_max_iso: str) -> List[Dict]:
+    try:
+        tmax = datetime.fromisoformat(t_max_iso.replace("Z","+00:00"))
+    except Exception:
+        tmax = datetime.now(timezone.utc)
+    kept = []
+    for d in docs:
+        try:
+            dt = datetime.fromisoformat(d["published"].replace("Z","+00:00"))
+            if dt <= tmax: kept.append(d)
+        except Exception:
+            kept.append(d)
+    return kept
 
 def format_evidence_block(evs: List[Dict]) -> str:
     lines = []
@@ -239,62 +313,6 @@ def format_evidence_block(evs: List[Dict]) -> str:
         lines.append(f"[{e['id']}] ({e.get('published','')}) {title} — {e.get('url','')}\n{snippet}")
     return "\n\n".join(lines)
 
-# Baseline NLI
-NLI_NAME = "roberta-large-mnli"
-nli_tok = AutoTokenizer.from_pretrained(NLI_NAME)
-nli_model = AutoModelForSequenceClassification.from_pretrained(NLI_NAME)
-nli = pipeline("text-classification", model=nli_model, tokenizer=nli_tok, return_all_scores=True, truncation=True, device=-1)
-
-def verify_with_nli(claim: str, evidence: List[Dict]) -> Dict:
-    best_ent_id, best_ent_p = None, 0.0
-    best_con_id, best_con_p = None, 0.0
-    for e in evidence or []:
-        prem = (e.get("text") or "").strip()
-        if not prem: continue
-        outputs = nli([{"text": prem, "text_pair": claim}])
-        probs = {d["label"].upper(): float(d["score"]) for d in outputs[0]}
-        ent, con = probs.get("ENTAILMENT", 0.0), probs.get("CONTRADICTION", 0.0)
-        if ent > best_ent_p: best_ent_id, best_ent_p = e.get("id"), ent
-        if con > best_con_p: best_con_id, best_con_p = e.get("id"), con
-    label, used = "NEI", []
-    conf = max(0.34, float(best_ent_p*0.5 + (1-best_con_p)*0.25))
-    rationale = "Insufficient or inconclusive evidence."
-    if best_ent_p >= 0.60 and (best_ent_p - best_con_p) >= 0.10:
-        label, used, conf, rationale = "SUPPORT", [best_ent_id] if best_ent_id else [], best_ent_p, "Top evidence entails the claim."
-    elif best_con_p >= 0.60 and (best_con_p - best_ent_p) >= 0.10:
-        label, used, conf, rationale = "REFUTE", [best_con_id] if best_con_id else [], best_con_p, "Top evidence contradicts the claim."
-    return {"label": label, "used_evidence_ids": used, "confidence": float(conf), "rationale": rationale}
-
-def verify_with_openai(claim: str, evidence: List[Dict]) -> Dict:
-    if not has_llm():
-        return verify_with_nli(claim, evidence)
-    try:
-        client = openai.OpenAI()
-        resp = client.chat.completions.create(
-            model=os.environ.get("OPENAI_MODEL","gpt-4o-mini"),
-            messages=[
-                {"role":"system","content":"You verify factual claims using only provided evidence and return strict JSON."},
-                {"role":"user","content": VERIFIER_PROMPT.format(claim=claim, evidence_block=format_evidence_block(evidence))}
-            ],
-            temperature=0.0,
-            response_format={"type": "json_object"}
-        )
-        j = json.loads(resp.choices[0].message.content)
-        return {"label": str(j.get("label","NEI")).upper(),
-                "used_evidence_ids": [str(x) for x in j.get("used_evidence_ids", [])],
-                "confidence": float(j.get("confidence", 0.5)),
-                "rationale": str(j.get("rationale","")).strip()[:300]}
-    except Exception as e:
-        alt = verify_with_nli(claim, evidence)
-        alt["rationale"] = f"NLI fallback due to LLM error: {e}"
-        return alt
-
-def enforce_json_schema(x: Dict) -> Dict:
-    return {"label": str(x.get("label","NEI")).upper(),
-            "used_evidence_ids": [str(i) for i in x.get("used_evidence_ids", []) if i],
-            "confidence": float(x.get("confidence", 0.5)),
-            "rationale": str(x.get("rationale","")).strip()[:300]}
-
 def verify_claim(claim_text: str, use_web: bool = True, use_wiki: bool = True,
                  allowlist: Optional[List[str]] = None, t_claim_iso: Optional[str] = None, k: int = 8) -> Dict:
     t_claim_iso = t_claim_iso or now_iso()
@@ -305,8 +323,8 @@ def verify_claim(claim_text: str, use_web: bool = True, use_wiki: bool = True,
     corpus_at_t = filter_by_time(docs, t_claim_iso)
     top_at_t = retrieve_hybrid(claim_text, corpus_at_t, k=k)
     top_now  = retrieve_hybrid(claim_text, docs,         k=k)
-    res_t = enforce_json_schema(verify_with_openai(claim_text, top_at_t))
-    res_n = enforce_json_schema(verify_with_openai(claim_text, top_now))
+    res_t = enforce_json_schema(verify_with_nli(claim_text, top_at_t))
+    res_n = enforce_json_schema(verify_with_nli(claim_text, top_now))
     return {"claim": claim_text, "t_claim": t_claim_iso, "label_at_t": res_t["label"], "label_now": res_n["label"],
             "used_evidence_ids_at_t": res_t["used_evidence_ids"], "used_evidence_ids_now": res_n["used_evidence_ids"],
             "confidence": float((res_t["confidence"] + res_n["confidence"]) / 2.0),
@@ -314,20 +332,28 @@ def verify_claim(claim_text: str, use_web: bool = True, use_wiki: bool = True,
             "evidence_top_now": top_now}
 
 def run_on_claims(claims: List[str], use_web: bool, use_wiki: bool, allowlist: List[str], k: int = 8) -> List[Dict]:
-    return [verify_claim(c.strip(), use_web=use_web, use_wiki=use_wiki, allowlist=allowlist, t_claim_iso=now_iso(), k=k)
-            for c in claims if c.strip()]
-
-# ===================== ASR + OCR =====================
+    outs = []
+    for c in claims:
+        c = (c or "").strip()
+        if not c: continue
+        outs.append(verify_claim(c, use_web=use_web, use_wiki=use_wiki, allowlist=allowlist, t_claim_iso=now_iso(), k=k))
+    return outs
+
+# ---------- ASR + OCR (guarded) ----------
 def extract_audio_ffmpeg(video_path: str, out_wav: str, sr: int = 16000) -> str:
     cmd = ["ffmpeg","-y","-i",video_path,"-vn","-acodec","pcm_s16le","-ar",str(sr),"-ac","1",out_wav]
-    subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True); return out_wav
+    subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+    return out_wav
 
 def run_whisper_asr(audio_path: str, model_size: str = "base", language: Optional[str] = None) -> str:
-    model = whisper.load_model(model_size)  # GPU auto if available
+    if whisper is None:
+        raise RuntimeError("Whisper not available. Ensure openai-whisper is installed and FFmpeg present.")
+    model = whisper.load_model(model_size)
     result = model.transcribe(audio_path, language=language) if language else model.transcribe(audio_path)
     return result.get("text","").strip()
 
 def download_video(url: str, out_dir: str = "videos") -> str:
+    # yt-dlp is installed via requirements; call binary
     os.makedirs(out_dir, exist_ok=True)
     out_tpl = os.path.join(out_dir, "%(title)s.%(ext)s")
     subprocess.run(["yt-dlp","-o",out_tpl,url], check=True)
@@ -341,6 +367,7 @@ def sample_frames_ffmpeg(video_path: str, out_dir: str = "frames", fps: float =
     return sorted(glob.glob(os.path.join(out_dir, "frame_*.jpg")))
 
 def preprocess_for_ocr(img_path: str):
+    if cv2 is None: return None
     img = cv2.imread(img_path, cv2.IMREAD_COLOR)
     if img is None: return None
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
@@ -351,6 +378,8 @@ def preprocess_for_ocr(img_path: str):
     return th
 
 def run_easyocr_on_frames(frames: List[str], languages: List[str] = ["en"], gpu: Optional[bool] = None, max_images: Optional[int] = None) -> List[str]:
+    if easyocr is None:
+        raise RuntimeError("EasyOCR not available. Ensure easyocr + opencv-python-headless are installed.")
     if gpu is None:
         gpu = True if (os.environ.get("SPACE_ID") or shutil.which("nvidia-smi")) else False
     reader = easyocr.Reader(languages, gpu=gpu)
@@ -402,7 +431,7 @@ def process_video(video_file: Optional[str] = None, video_url: Optional[str] = N
     return {"workdir": workdir, "video_path": vp, "asr_text": asr_text, "ocr_lines": ocr_lines,
             "aggregated_text": agg, "suggested_claims": suggestions}
 
-# Claim suggestions
+# ---------- claim suggestions ----------
 CLAIM_MIN_LEN = 12
 VERB_TRIGGERS = r"\b(" + "|".join([
     "is","are","was","were","has","have","had","will","can","does","did",
@@ -423,7 +452,7 @@ def suggest_claims(text: str, top_k: int = 10) -> List[str]:
         candidates = [s for _, s in sorted(scored, key=lambda x: -x[0])[:top_k]]
     return candidates[:top_k]
 
-# ===================== Gradio Theme + UI =====================
+# ---------- Gradio theme & UI ----------
 THEME_CSS = """
 <style>
   body, .gradio-container {
@@ -460,10 +489,7 @@ def ui_run_factcheck(claims_text: str, use_web: bool, use_wiki: bool, allowlist_
     allow = [d.strip() for d in (allowlist_str or ", ".join(DEFAULT_ALLOWLIST)).split(",") if d.strip()]
     res = run_on_claims(claims, use_web=use_web, use_wiki=use_wiki, allowlist=allow, k=8)
 
-    # pretty text + table
-    used = lambda v: "|".join(v.get("used_evidence_ids_now", []))
-    rows = []
-    cards = []
+    rows, cards = [], []
     for v in res:
         lines = ["─"*74, f"CLAIM: {v['claim']}", f"t_claim: {v['t_claim']}",
                  f"verdict@T: {v['label_at_t']} | verdict@Now: {v['label_now']} | confidence: {v['confidence']:.2f}",
@@ -480,7 +506,8 @@ def ui_run_factcheck(claims_text: str, use_web: bool, use_wiki: bool, allowlist_
                 lines.append(f"    {snippet}")
         cards.append("\n".join(lines))
         rows.append({"claim": v["claim"], "verdict_at_t": v["label_at_t"], "verdict_now": v["label_now"],
-                    "confidence": round(float(v["confidence"]), 3), "used_ids": used(v)})
+                    "confidence": round(float(v["confidence"]), 3),
+                    "used_ids": "|".join(v.get("used_evidence_ids_now", []))})
 
     df = pd.DataFrame(rows)
     return "\n\n".join(cards), df
@@ -488,9 +515,12 @@ def ui_run_factcheck(claims_text: str, use_web: bool, use_wiki: bool, allowlist_
 def ui_ingest_and_suggest(video_file, video_url, whisper_model, asr_language, ocr_langs, fps, max_ocr_images):
     try: vp = video_file.name if video_file else None
     except Exception: vp = None
-    out = process_video(video_file=vp, video_url=video_url,
-                        whisper_model=whisper_model, asr_language=asr_language,
-                        ocr_langs=ocr_langs, fps=fps, max_ocr_images=int(max_ocr_images))
+    try:
+        out = process_video(video_file=vp, video_url=video_url,
+                            whisper_model=whisper_model, asr_language=asr_language or None,
+                            ocr_langs=ocr_langs, fps=float(fps), max_ocr_images=int(max_ocr_images))
+    except Exception as e:
+        return f"Error during ingest: {e}", "", "", "", ""
     asr_preview = (out["asr_text"][:1200] + "...") if len(out["asr_text"]) > 1200 else out["asr_text"]
     ocr_preview = "\n".join(out["ocr_lines"][:50])
     agg_preview = (out["aggregated_text"][:2000] + "...") if len(out["aggregated_text"]) > 2000 else out["aggregated_text"]
@@ -505,8 +535,8 @@ with gr.Blocks(css=THEME_CSS, fill_height=True) as demo:
             with gr.Column(scale=1):
                 claims_box = gr.Textbox(label="Claims (one per line)", lines=8, placeholder="e.g. NASA predicts three days of darkness", elem_classes=["glass"])
                 with gr.Row():
-                    use_web = gr.Checkbox(value=USE_WEB_DEFAULT, label="Use Web retrieval")
-                    use_wiki = gr.Checkbox(value=USE_WIKI_DEFAULT, label="Use Wikipedia")
+                    use_web = gr.Checkbox(value=True, label="Use Web retrieval")
+                    use_wiki = gr.Checkbox(value=True, label="Use Wikipedia")
                 allowlist_box = gr.Textbox(label="Domain allowlist (comma-separated)", value=", ".join(DEFAULT_ALLOWLIST), lines=2)
                 run_btn = gr.Button("Run Fact-Check", elem_classes=["neon-btn"])
             with gr.Column(scale=1):