Update app.py

app.py

@@ -1,6 +1,6 @@
 import gradio as gr
 from transformers import pipeline
-import feedparser, requests, re, datetime, os, json
+import feedparser, requests, re, time, datetime
 
 # ---------------------------
 # Load Models
@@ -31,46 +31,25 @@ RSS_FEEDS = {
 
 GOOGLE_API_KEY = "AIzaSyAC56onKwR17zd_djUPEfGXQACy9qRjDxw"
 GOOGLE_CX = "87391aed073954cae"
-GOOGLE_DAILY_LIMIT = 100
-QUOTA_FILE = "google_quota.json"
-
-# ---------------------------
-# Quota Management (UTC Reset)
-# ---------------------------
-def load_quota():
-    if os.path.exists(QUOTA_FILE):
-        with open(QUOTA_FILE, "r") as f:
-            data = json.load(f)
-        reset_time = datetime.datetime.fromisoformat(data["reset"])
-        if datetime.datetime.utcnow() > reset_time:
-            return {"count": 0, "reset": (datetime.datetime.utcnow() + datetime.timedelta(days=1)).isoformat()}
-        return data
-    return {"count": 0, "reset": (datetime.datetime.utcnow() + datetime.timedelta(days=1)).isoformat()}
 
-def save_quota(data):
-    with open(QUOTA_FILE, "w") as f:
-        json.dump(data, f)
-
-def can_use_google():
-    quota = load_quota()
-    return quota["count"] < GOOGLE_DAILY_LIMIT
-
-def increment_google_quota():
-    quota = load_quota()
-    quota["count"] += 1
-    save_quota(quota)
+# Google search quota tracking
+google_quota = {"count": 0, "date": datetime.date.today()}
+GOOGLE_DAILY_LIMIT = 100
 
 # ---------------------------
 # Claim Extraction
 # ---------------------------
 def extract_claims(page_text):
-    """Extract top 10 factual claims from page text."""
-    sentences = [s.strip() for s in page_text.split(".") if len(s.strip()) > 5]
+    """Extract top 10 factual claims from page text (split on ., , and ;)"""
+    chunks = re.split(r'[.,;]', page_text)
+    sentences = [s.strip() for s in chunks if len(s.strip()) > 5]
+
     results = []
     for s in sentences:
         out = claim_classifier(s, claim_labels)
         if out["labels"][0] == "factual claim":
             results.append(s)
+
     return results[:10]
 
 # ---------------------------
@@ -83,29 +62,36 @@ def detect_ai(texts):
     results = []
     for t in texts:
         out = ai_detector(t)
-        results.append({"text": t, "label": out[0]["label"], "score": round(out[0]["score"], 3)})
+        raw_label = out[0]["label"]
+
+        # Map labels to friendlier ones
+        if raw_label.lower() in ["fake", "ai-generated"]:
+            label = "AI-generated"
+        else:
+            label = "Human"
+
+        results.append({
+            "text": t,
+            "label": label,
+            "score": round(out[0]["score"], 3)
+        })
     return results
 
 # ---------------------------
 # Evidence Gathering
 # ---------------------------
-def fetch_rss(claim):
-    """Search RSS feeds for claim (max 2 results)."""
-    results = []
+def fetch_rss_articles():
+    articles = []
     for source, url in RSS_FEEDS.items():
         try:
             feed = feedparser.parse(url)
-            for entry in feed.entries[:15]:
-                if re.search(claim, entry.title, re.IGNORECASE) or re.search(claim, entry.summary, re.IGNORECASE):
-                    results.append(f"[{source}] {entry.title}: {entry.summary}")
-                if len(results) >= 2:
-                    return results
+            for entry in feed.entries[:5]:
+                articles.append(f"[{source}] {entry.title}: {entry.summary}")
         except Exception:
             continue
-    return results
+    return articles
 
 def fetch_wikipedia(claim):
-    """Fetch Wikipedia summary (max 2 results)."""
     try:
         url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{requests.utils.quote(claim)}"
         r = requests.get(url).json()
@@ -115,16 +101,22 @@ def fetch_wikipedia(claim):
         return []
     return []
 
-def fetch_google(claim):
-    """Google Custom Search (max 2 results, quota-limited)."""
-    if not can_use_google():
+def fetch_google_search(claim):
+    global google_quota
+    today = datetime.date.today()
+    # reset quota daily
+    if google_quota["date"] != today:
+        google_quota = {"count": 0, "date": today}
+
+    if google_quota["count"] >= GOOGLE_DAILY_LIMIT:
         return ["[Google] Daily quota reached (100 queries)."]
+
     try:
         url = f"https://www.googleapis.com/customsearch/v1?q={requests.utils.quote(claim)}&key={GOOGLE_API_KEY}&cx={GOOGLE_CX}"
         r = requests.get(url).json()
-        increment_google_quota()
+        google_quota["count"] += 1
         items = r.get("items", [])
-        return [f"[Google] {item['title']}: {item['snippet']}" for item in items[:2]]
+        return [f"[Google] {item['title']}: {item['snippet']}" for item in items[:3]]
     except Exception:
         return []
 
@@ -135,19 +127,16 @@ def fact_check(claims, evidence_texts, threshold=0.7):
     results = []
     for c in claims:
         for ev in evidence_texts:
-            try:
-                out = nli_pipeline(hypothesis=c, premise=ev)
-                label = out[0]["label"]
-                score = round(out[0]["score"], 3)
-                if score >= threshold:
-                    results.append({
-                        "claim": c,
-                        "evidence": ev,
-                        "label": label,
-                        "score": score
-                    })
-            except Exception:
-                continue
+            out = nli_pipeline(hypothesis=c, premise=ev)
+            label = out[0]["label"]
+            score = round(out[0]["score"], 3)
+            if score >= threshold:
+                results.append({
+                    "claim": c,
+                    "evidence": ev,
+                    "label": label,
+                    "score": score
+                })
     return results
 
 # ---------------------------
@@ -157,32 +146,32 @@ def predict(page_text=""):
     """
     1. Extract claims from page_text
     2. Run AI Detection
-    3. Gather evidence (Google + Wikipedia + RSS, all tied to claims, quota aware)
-    4. Fact-check claims against evidence
+    3. Gather evidence (RSS + Wikipedia + Google, with quota)
+    4. Fact-check claims against evidence (only strong matches kept)
     """
+    # Step 1: Extract claims
     claims = extract_claims(page_text) if page_text else []
+
+    # Step 2: AI detection
     ai_results = detect_ai(claims) if claims else []
 
-    evidence_map = {}
+    # Step 3: Evidence gathering
+    evidence_texts = []
     for c in claims:
-        evidence_map[c] = []
-        evidence_map[c].extend(fetch_google(c))
-        evidence_map[c].extend(fetch_wikipedia(c))
-        evidence_map[c].extend(fetch_rss(c))
-
-    evidence_texts = [ev for evs in evidence_map.values() for ev in evs]
-
-    fc_results = fact_check(claims, evidence_texts[:20]) if claims and evidence_texts else []
+        evidence_texts.extend(fetch_wikipedia(c))
+        evidence_texts.extend(fetch_google_search(c))
+    evidence_texts.extend(fetch_rss_articles())
 
-    quota = load_quota()
+    # Step 4: Fact-checking
+    fc_results = fact_check(claims, evidence_texts[:15]) if claims and evidence_texts else []
 
     return {
         "claims": claims,
         "ai_detection": ai_results,
-        "google_quota_used": quota["count"],
-        "google_quota_reset": quota["reset"],
-        "evidence_samples": {c: evidence_map[c][:3] for c in claims},
-        "fact_checking": fc_results[:15]
+        "google_quota_used": google_quota["count"],
+        "google_quota_reset": str(datetime.datetime.combine(google_quota["date"] + datetime.timedelta(days=1), datetime.time.min)),
+        "evidence_samples": {c: evidence_texts[:2] for c in claims[:2]},  # sample evidence
+        "fact_checking": fc_results[:10]
     }
 
 # ---------------------------