Update app.py

app.py

@@ -1,28 +1,40 @@
 import gradio as gr
 from transformers import pipeline
+import feedparser, requests, re, wikipedia, time
+from concurrent.futures import ThreadPoolExecutor
 
 # ---------------------------
 # Load Models
 # ---------------------------
-# Claim Extraction → Zero-Shot Classifier
-# (using MoritzLaurer public DeBERTa MNLI model)
 claim_model_name = "MoritzLaurer/DeBERTa-v3-base-mnli"
 claim_classifier = pipeline("zero-shot-classification", model=claim_model_name, device=-1)
 claim_labels = ["factual claim", "opinion", "personal anecdote", "other"]
 
-# AI Text Detection → OpenAI Detector (Roberta-based)
 ai_detect_model_name = "roberta-base-openai-detector"
 ai_detector = pipeline("text-classification", model=ai_detect_model_name, device=-1)
 
-# Fact-Checking (NLI) → DistilBART MNLI
 nli_model_name = "valhalla/distilbart-mnli-12-3"
 nli_pipeline = pipeline("text-classification", model=nli_model_name, tokenizer=nli_model_name, device=-1)
 
 # ---------------------------
-# Functions
+# Fact-check sources
+# ---------------------------
+FACT_FEEDS = {
+    "Snopes": "https://www.snopes.com/feed/",
+    "PolitiFact": "https://www.politifact.com/rss/factchecks/",
+    "FactCheck.org": "https://www.factcheck.org/feed/",
+    "AP News Fact Check": "https://apnews.com/hub/ap-fact-check.rss",
+    "Reuters Fact Check": "https://www.reuters.com/fact-check/rss",
+}
+
+GOOGLE_API_KEY = "AIzaSyAC56onKwR17zd_djUPEfGXQACy9qRjDxw"
+GOOGLE_CX = "YOUR_SEARCH_ENGINE_ID"  # you need to set up a CSE at Google
+
+
+# ---------------------------
+# Claim Extraction
 # ---------------------------
 def extract_claims(page_text):
-    """Extract top 5 factual claims from page text."""
     sentences = [s.strip() for s in page_text.split(".") if len(s.strip()) > 5]
     results = []
     for s in sentences:
@@ -32,8 +44,10 @@ def extract_claims(page_text):
     return results[:5]
 
 
+# ---------------------------
+# AI Detection
+# ---------------------------
 def detect_ai(texts):
-    """Detect whether input text is AI-generated or human-written."""
     if isinstance(texts, str):
         texts = [texts]
     results = []
@@ -43,62 +57,104 @@ def detect_ai(texts):
     return results
 
 
-def fact_check(claims, evidence_text):
-    """Run NLI-based fact-checking between claims and provided evidence text."""
-    if isinstance(claims, str):
-        claims = [claims]
+# ---------------------------
+# Evidence Fetchers
+# ---------------------------
+def fetch_rss_evidence(claim):
+    evidence = []
+    for name, url in FACT_FEEDS.items():
+        try:
+            feed = feedparser.parse(url)
+            for entry in feed.entries[:10]:
+                if re.search(claim[:30], entry.title + " " + entry.get("summary", ""), re.I):
+                    evidence.append(f"[{name}] {entry.title} - {entry.link}")
+        except Exception:
+            continue
+    return evidence
+
+
+def fetch_wikipedia(claim):
+    try:
+        results = wikipedia.search(claim)
+        if results:
+            page = wikipedia.page(results[0])
+            return [f"[Wikipedia] {page.title}: {page.summary[:300]}..."]
+    except Exception:
+        return []
+    return []
+
+
+def fetch_google_cse(claim):
+    try:
+        url = (
+            f"https://www.googleapis.com/customsearch/v1?q={requests.utils.quote(claim)}"
+            f"&key={GOOGLE_API_KEY}&cx={GOOGLE_CX}"
+        )
+        r = requests.get(url).json()
+        if "items" in r:
+            return [f"[Google] {item['title']} - {item['link']}" for item in r["items"][:3]]
+    except Exception:
+        return []
+    return []
+
+
+def gather_evidence(claim):
+    evidence = []
+    with ThreadPoolExecutor() as ex:
+        futures = [
+            ex.submit(fetch_rss_evidence, claim),
+            ex.submit(fetch_wikipedia, claim),
+            ex.submit(fetch_google_cse, claim),
+        ]
+        for f in futures:
+            try:
+                evidence.extend(f.result())
+            except:
+                continue
+    return evidence[:5]
+
+
+# ---------------------------
+# Fact-Checking
+# ---------------------------
+def fact_check(claims):
     results = []
     for c in claims:
-        out = nli_pipeline(hypothesis=c, sequence_pair=evidence_text)
-        results.append({"claim": c, "label": out[0]["label"], "score": round(out[0]["score"], 3)})
+        evidence_list = gather_evidence(c)
+        if not evidence_list:
+            results.append({"claim": c, "label": "no evidence found", "score": 0.0})
+            continue
+
+        best_ev = evidence_list[0]
+        out = nli_pipeline(hypothesis=c, sequence_pair=best_ev)
+        results.append(
+            {"claim": c, "evidence": best_ev, "label": out[0]["label"], "score": round(out[0]["score"], 3)}
+        )
     return results
 
 
 # ---------------------------
-# Unified Predict Function
+# Unified Predict
 # ---------------------------
-def predict(page_text="", selected_text="", evidence_text=""):
-    """
-    1. Extract top 5 claims from page_text
-    2. Run AI Detection on claims + selected_text
-    3. Run Fact-Checking on claims + evidence_text if provided
-    """
-    # Extract claims
+def predict(page_text=""):
     claims = extract_claims(page_text) if page_text else []
+    ai_results = detect_ai(claims) if claims else []
+    fc_results = fact_check(claims) if claims else []
 
-    # Combine claims + selected text for AI detection
-    ai_input = claims.copy()
-    if selected_text:
-        ai_input.append(selected_text)
-    ai_results = detect_ai(ai_input) if ai_input else []
-
-    # Fact-checking: only if evidence is provided
-    fc_results = fact_check(claims + ([selected_text] if selected_text else []), evidence_text) if evidence_text else []
-
-    return {
-        "claims": claims,
-        "ai_detection": ai_results,
-        "fact_checking": fc_results
-    }
+    return {"claims": claims, "ai_detection": ai_results, "fact_checking": fc_results}
 
 
 # ---------------------------
 # Gradio UI
 # ---------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## EduShield AI Backend - Predict API & UI")
+    gr.Markdown("## EduShield AI Backend - Predict API & UI (with Fact-Check Sources)")
 
     page_text_input = gr.Textbox(label="Full Page Text", lines=10, placeholder="Paste page text here...")
-    selected_text_input = gr.Textbox(label="Selected Text", lines=5, placeholder="Paste selected text here...")
-    evidence_input = gr.Textbox(label="Evidence Text", lines=5, placeholder="Paste evidence text here...")
     predict_btn = gr.Button("Run Predict")
     output_json = gr.JSON(label="Predict Results")
 
-    predict_btn.click(
-        predict,
-        inputs=[page_text_input, selected_text_input, evidence_input],
-        outputs=output_json
-    )
+    predict_btn.click(predict, inputs=[page_text_input], outputs=output_json)
 
 # ---------------------------
 # Launch