Spaces:
Sleeping
Sleeping
| """ | |
| ui.py — Information Integrity Analyzer | |
| One input. Automatic pipeline. Rich verdict output. | |
| """ | |
| # Load .env first so all API keys are available before any module reads os.getenv() | |
| try: | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| except ImportError: | |
| pass | |
| import re | |
| import time | |
| from typing import Generator | |
| import gradio as gr | |
| from data_collector import CollectionRequest, DataCollector | |
| from environment import InformationIntegrityEnv | |
| from explainability import ExplainabilityEngine, build_reasoning_from_episode | |
| from models import Action | |
| from tasks.graders import GraderFactory | |
| try: | |
| from reasoning import DeterministicReasoningEngine, reason_over_claims | |
| from retrieval import RetrievalPipeline | |
| from decision_engine import make_moderation_decisions | |
| _REASONING_AVAILABLE = True | |
| except Exception: | |
| _REASONING_AVAILABLE = False | |
| collector = DataCollector() | |
| explainer = ExplainabilityEngine() | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # Claim extractor | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| _SIGNALS = re.compile( | |
| r"\b(confirm|prove|show|reveal|say|claim|report|find|cause|lead to|linked to|" | |
| r"associated with|increase|decrease|never|always|all|every|none|proven|fact|" | |
| r"truth|confirmed|vaccine|virus|cancer|disease|drug|radiation|5g|covid|" | |
| r"lockdown|percent|%|study|research|scientist|doctor|expert|government|" | |
| r"permanently|alter|spread|hide|secret|conspiracy|banned|cure|prevent)\b", | |
| re.IGNORECASE, | |
| ) | |
| _SKIP = re.compile( | |
| r"^(share|follow|click|subscribe|watch|read|download|buy|sign up|please|" | |
| r"thank you|breaking:|update:|alert:|warning:)", | |
| re.IGNORECASE, | |
| ) | |
| def extract_claims(text: str) -> list[str]: | |
| sentences = re.split(r"(?<=[.!?])\s+|\s*[|•–—]\s*", text.strip()) | |
| claims, seen = [], set() | |
| for s in sentences: | |
| s = s.strip().strip("\"'.,!?") | |
| if len(s) < 12 or len(s) > 280: | |
| continue | |
| if _SKIP.match(s): | |
| continue | |
| if _SIGNALS.search(s) and s.lower() not in seen: | |
| seen.add(s.lower()) | |
| claims.append(s) | |
| if not claims: | |
| claims = [s.strip() for s in sentences if len(s.strip()) >= 15][:3] | |
| return claims[:6] | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # HTML card builders | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| def _progress_html(stage: str, pct: int, msg: str) -> str: | |
| stages = ["Extracting claims", "Searching sources", "Running analysis", "Complete"] | |
| dots = "".join( | |
| f'<span style="display:inline-block;width:10px;height:10px;border-radius:50%;' | |
| f'margin:0 4px;background:{"#4f8ef7" if i <= stages.index(stage) else "#dde3ee"}' | |
| f'"></span>' | |
| for i, s in enumerate(stages) | |
| if (i <= stages.index(stage)) or True | |
| ) | |
| return f""" | |
| <div style="font-family:'Inter',sans-serif;padding:28px 32px;background:#f8faff; | |
| border-radius:16px;border:1px solid #e0e7ff;"> | |
| <div style="font-size:15px;color:#5c6bc0;margin-bottom:14px;font-weight:600;"> | |
| {stage}… <span style="font-weight:400;color:#8e99c5">{msg}</span> | |
| </div> | |
| <div style="background:#e8edf8;border-radius:8px;height:8px;overflow:hidden;"> | |
| <div style="background:linear-gradient(90deg,#4f8ef7,#7c6af7);height:100%; | |
| width:{pct}%;transition:width 0.4s ease;border-radius:8px;"></div> | |
| </div> | |
| </div>""" | |
| def _verdict_color(decision: str) -> tuple[str, str, str]: | |
| """Returns (bg_gradient, text_color, icon).""" | |
| return { | |
| "remove": ("linear-gradient(135deg,#ff4444,#d32f2f)", "#fff", "🚫"), | |
| "flag": ("linear-gradient(135deg,#ff9800,#e65100)", "#fff", "⚠️"), | |
| "allow": ("linear-gradient(135deg,#43a047,#1b5e20)", "#fff", "✅"), | |
| }.get(decision, ("linear-gradient(135deg,#607d8b,#37474f)", "#fff", "❓")) | |
| def _reliability_bar(score: float) -> str: | |
| filled = int(score * 12) | |
| color = "#e53935" if score < 0.4 else "#fb8c00" if score < 0.7 else "#43a047" | |
| bar = f'<span style="color:{color}">{"█"*filled}</span>' \ | |
| f'<span style="color:#e0e0e0">{"█"*(12-filled)}</span>' | |
| return f'<span style="font-family:monospace;font-size:12px">{bar}</span> ' \ | |
| f'<span style="font-size:12px;color:#666">{score:.2f}</span>' | |
| def _stance_badge(stance: str) -> str: | |
| cfg = { | |
| "contradicting": ("#fdecea", "#c62828", "✗ Contradicts"), | |
| "supporting": ("#e8f5e9", "#2e7d32", "✓ Supports"), | |
| "neutral": ("#f3f4f6", "#555", "· Neutral"), | |
| }.get(stance, ("#f3f4f6", "#555", stance)) | |
| bg, fg, label = cfg | |
| return (f'<span style="background:{bg};color:{fg};padding:2px 8px;' | |
| f'border-radius:12px;font-size:12px;font-weight:600">{label}</span>') | |
| def _claim_badge(status: str) -> str: | |
| cfg = { | |
| "false": ("#fdecea", "#c62828", "FALSE"), | |
| "true": ("#e8f5e9", "#2e7d32", "TRUE"), | |
| "partially_true": ("#fff8e1", "#e65100", "PARTIAL"), | |
| "unknown": ("#f3f4f6", "#555", "UNKNOWN"), | |
| "unverified": ("#f3f4f6", "#9e9e9e", "UNVERIFIED"), | |
| }.get(status.lower() if isinstance(status, str) else "unverified", | |
| ("#f3f4f6", "#555", status)) | |
| bg, fg, label = cfg | |
| return (f'<span style="background:{bg};color:{fg};padding:3px 10px;' | |
| f'border-radius:12px;font-size:11px;font-weight:700;' | |
| f'letter-spacing:.5px">{label}</span>') | |
| def build_result_html(statement: str, scenario: dict, obs, result, explanation: str, | |
| per_claim_reasoning: dict | None = None) -> str: | |
| decision = result.decision or "unknown" | |
| grad, txt_col, icon = _verdict_color(decision) | |
| correct_badge = ( | |
| '<span style="background:#e8f5e9;color:#2e7d32;padding:3px 10px;' | |
| 'border-radius:12px;font-size:12px;font-weight:600">✓ Correct</span>' | |
| if result.correct else | |
| '<span style="background:#fdecea;color:#c62828;padding:3px 10px;' | |
| 'border-radius:12px;font-size:12px;font-weight:600">✗ Incorrect</span>' | |
| ) | |
| # ── Claims section | |
| claims_html = "" | |
| for c in obs.claims: | |
| status = c.verification_status | |
| if hasattr(status, "value"): | |
| status = status.value | |
| conf_pct = int(c.confidence * 100) | |
| claims_html += f""" | |
| <div style="display:flex;align-items:flex-start;gap:12px;padding:12px 0; | |
| border-bottom:1px solid #f0f0f0;"> | |
| <div style="flex:1;font-size:14px;color:#333;line-height:1.5">{c.text}</div> | |
| <div style="display:flex;flex-direction:column;align-items:flex-end;gap:4px; | |
| white-space:nowrap"> | |
| {_claim_badge(status)} | |
| <span style="font-size:11px;color:#999">conf {conf_pct}%</span> | |
| </div> | |
| </div>""" | |
| # ── Sources section (top 6 by reliability) | |
| sources = sorted(scenario["sources"], key=lambda s: -s["reliability"])[:6] | |
| sources_html = "" | |
| for s in sources: | |
| domain = re.sub(r"https?://(www\.)?", "", s["url"]).split("/")[0] | |
| sources_html += f""" | |
| <div style="padding:12px;border-radius:10px;background:#fafafa; | |
| border:1px solid #eee;margin-bottom:8px"> | |
| <div style="display:flex;justify-content:space-between;align-items:center; | |
| flex-wrap:wrap;gap:6px"> | |
| <span style="font-size:13px;font-weight:600;color:#333">{s['title'][:65]}</span> | |
| {_stance_badge(s['stance'])} | |
| </div> | |
| <div style="font-size:12px;color:#888;margin:4px 0">{domain} · {s['source_type']}</div> | |
| <div style="font-size:12px;color:#555;line-height:1.5;margin:6px 0"> | |
| {s['text'][:180]}{'…' if len(s['text'])>180 else ''} | |
| </div> | |
| <div>Reliability: {_reliability_bar(s['reliability'])}</div> | |
| </div>""" | |
| if not sources_html: | |
| sources_html = '<p style="color:#999;font-style:italic">No sources fetched — try adding API keys for richer results.</p>' | |
| # ── Reward breakdown | |
| bd = result.reward_breakdown | |
| reward_rows = "" | |
| for label, val in [ | |
| ("Claim verification", bd.verify_claim_reward), | |
| ("Source checks", bd.check_source_reward), | |
| ("Multi-source bonus", bd.multi_source_bonus), | |
| ("Decision accuracy", bd.decision_reward), | |
| ("Premature penalty", bd.premature_penalty), | |
| ("Redundancy penalty", bd.redundant_penalty), | |
| ("Inefficiency", bd.inefficiency_penalty), | |
| ("Over-aggression", bd.aggression_penalty), | |
| ]: | |
| if val == 0: | |
| continue | |
| color = "#2e7d32" if val > 0 else "#c62828" | |
| reward_rows += f""" | |
| <div style="display:flex;justify-content:space-between;padding:5px 0; | |
| border-bottom:1px solid #f5f5f5;font-size:13px"> | |
| <span style="color:#555">{label}</span> | |
| <span style="color:{color};font-weight:600">{val:+.2f}</span> | |
| </div>""" | |
| # ── Grader sub-scores | |
| grader = GraderFactory.get(scenario["difficulty"]) | |
| gbd = grader.score_breakdown( | |
| decision = result.decision or "none", | |
| ground_truth = result.ground_truth, | |
| sources_checked = list(range(result.sources_checked)), | |
| claims_verified = list(range(result.claims_verified)), | |
| step_count = result.steps_taken, | |
| all_source_ids = [s["id"] for s in scenario["sources"]], | |
| all_claim_ids = [c["id"] for c in scenario["claims"]], | |
| ) | |
| grader_bars = "" | |
| for sub_label, sub_val in [ | |
| ("Decision", gbd["decision_sub_score"]), | |
| ("Evidence", gbd["evidence_sub_score"]), | |
| ("Reasoning", gbd["reasoning_sub_score"]), | |
| ("Efficiency", gbd["efficiency_sub_score"]), | |
| ]: | |
| pct = int(sub_val * 100) | |
| colr = "#e53935" if pct < 50 else "#fb8c00" if pct < 75 else "#43a047" | |
| grader_bars += f""" | |
| <div style="margin-bottom:8px"> | |
| <div style="display:flex;justify-content:space-between;font-size:12px; | |
| color:#555;margin-bottom:3px"> | |
| <span>{sub_label}</span><span style="color:{colr};font-weight:600">{pct}%</span> | |
| </div> | |
| <div style="background:#eee;border-radius:4px;height:6px"> | |
| <div style="background:{colr};width:{pct}%;height:100%;border-radius:4px"></div> | |
| </div> | |
| </div>""" | |
| # ── Deterministic Reasoning breakdown (new) | |
| reasoning_html = "" | |
| if per_claim_reasoning: | |
| reasoning_html = """ | |
| <div style="background:#fff;border-radius:14px;border:1px solid #e8ecf4; | |
| padding:20px 24px;margin-bottom:20px"> | |
| <div style="font-size:11px;font-weight:700;color:#9ca3af;letter-spacing:1px; | |
| text-transform:uppercase;margin-bottom:14px"> | |
| 🧠 Deterministic Reasoning Engine | |
| </div>""" | |
| for claim_text, r in per_claim_reasoning.items(): | |
| score = r["evidence_score"] | |
| conf = r["confidence"] | |
| dec = r["decision"] | |
| n_sup = r["n_supporting"] | |
| n_con = r["n_contradicting"] | |
| n_neu = r["n_neutral"] | |
| dec_col = {"allow": "#2e7d32", "flag": "#e65100", "remove": "#c62828"}.get(dec, "#555") | |
| score_col = "#c62828" if score < -0.3 else "#2e7d32" if score > 0.3 else "#e65100" | |
| reasoning_html += f""" | |
| <div style="background:#f8faff;border-radius:10px;padding:14px 18px;margin-bottom:12px; | |
| border-left:4px solid {dec_col}"> | |
| <div style="font-size:13px;color:#444;font-style:italic;margin-bottom:8px"> | |
| "{claim_text[:100]}{'…' if len(claim_text)>100 else ''}" | |
| </div> | |
| <div style="display:flex;gap:12px;flex-wrap:wrap;margin-bottom:8px"> | |
| <span style="background:{dec_col};color:#fff;padding:2px 10px;border-radius:10px; | |
| font-size:12px;font-weight:700;text-transform:uppercase">{dec}</span> | |
| <span style="font-size:12px;color:{score_col};font-weight:600"> | |
| Score: {score:+.3f}</span> | |
| <span style="font-size:12px;color:#888">Confidence: {conf}</span> | |
| <span style="font-size:12px;color:#2e7d32">▲ {n_sup} supporting</span> | |
| <span style="font-size:12px;color:#c62828">▼ {n_con} contradicting</span> | |
| <span style="font-size:12px;color:#888">· {n_neu} neutral</span> | |
| </div>""" | |
| # Safety rules fired | |
| if r.get("safety_rules_fired"): | |
| for rule in r["safety_rules_fired"]: | |
| rule_name = rule.split(":")[0] | |
| rule_desc = rule[len(rule_name)+1:].strip() | |
| reasoning_html += f""" | |
| <div style="font-size:11px;color:#e65100;background:#fff8e1;padding:4px 10px; | |
| border-radius:6px;margin-bottom:4px"> | |
| ⚠ <b>{rule_name}</b>: {rule_desc} | |
| </div>""" | |
| # Source breakdown (top 4) | |
| sb = r.get("source_breakdown", [])[:4] | |
| if sb: | |
| reasoning_html += '<div style="margin-top:8px">' | |
| for src in sb: | |
| contrib = src["contribution"] | |
| c_col = "#c62828" if contrib < 0 else "#2e7d32" if contrib > 0 else "#888" | |
| reasoning_html += f""" | |
| <div style="display:flex;justify-content:space-between;font-size:11px; | |
| color:#555;padding:2px 0;border-bottom:1px solid #eee"> | |
| <span style="flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap; | |
| max-width:420px">{src['title'][:70]}</span> | |
| <span style="margin:0 8px">{_stance_badge(src['stance'])}</span> | |
| <span style="font-weight:600;color:{c_col};white-space:nowrap"> | |
| {contrib:+.3f}</span> | |
| </div>""" | |
| reasoning_html += "</div>" | |
| reasoning_html += "</div>" | |
| reasoning_html += "</div>" | |
| # ── Explanation (pre-formatted) | |
| expl_lines = explanation.replace("<", "<").replace(">", ">") | |
| expl_html = f'<pre style="font-family:inherit;font-size:13px;line-height:1.7;' \ | |
| f'white-space:pre-wrap;margin:0;color:#333">{expl_lines}</pre>' | |
| return f""" | |
| <div style="font-family:'Inter',system-ui,sans-serif;max-width:960px;margin:0 auto"> | |
| <!-- VERDICT BANNER --> | |
| <div style="background:{grad};border-radius:16px;padding:28px 32px; | |
| margin-bottom:24px;display:flex;align-items:center;gap:20px"> | |
| <div style="font-size:52px">{icon}</div> | |
| <div> | |
| <div style="color:rgba(255,255,255,.75);font-size:13px; | |
| font-weight:600;letter-spacing:1px;text-transform:uppercase"> | |
| Moderation Verdict | |
| </div> | |
| <div style="color:{txt_col};font-size:36px;font-weight:800; | |
| line-height:1.1;text-transform:uppercase">{decision}</div> | |
| <div style="color:rgba(255,255,255,.85);font-size:13px;margin-top:4px"> | |
| Difficulty: <b>{scenario['difficulty']}</b> · | |
| Steps: <b>{result.steps_taken}</b> · | |
| Reward: <b>{result.total_reward:+.2f}</b> · | |
| Grader: <b>{result.grader_score:.0%}</b> | |
| {correct_badge} | |
| </div> | |
| </div> | |
| </div> | |
| <!-- STATEMENT --> | |
| <div style="background:#fff;border-radius:14px;border:1px solid #e8ecf4; | |
| padding:20px 24px;margin-bottom:20px"> | |
| <div style="font-size:11px;font-weight:700;color:#9ca3af;letter-spacing:1px; | |
| text-transform:uppercase;margin-bottom:8px">Statement Reviewed</div> | |
| <div style="font-size:15px;color:#1f2937;line-height:1.6; | |
| font-style:italic">"{statement}"</div> | |
| </div> | |
| <!-- CLAIMS + SOURCES (two col) --> | |
| <div style="display:grid;grid-template-columns:1fr 1fr;gap:20px;margin-bottom:20px"> | |
| <!-- Claims --> | |
| <div style="background:#fff;border-radius:14px;border:1px solid #e8ecf4; | |
| padding:20px 24px"> | |
| <div style="font-size:11px;font-weight:700;color:#9ca3af;letter-spacing:1px; | |
| text-transform:uppercase;margin-bottom:12px"> | |
| Claims Verified ({len(obs.claims)}) | |
| </div> | |
| {claims_html} | |
| </div> | |
| <!-- Scores --> | |
| <div style="background:#fff;border-radius:14px;border:1px solid #e8ecf4; | |
| padding:20px 24px"> | |
| <div style="font-size:11px;font-weight:700;color:#9ca3af;letter-spacing:1px; | |
| text-transform:uppercase;margin-bottom:14px">Grader Score Breakdown</div> | |
| {grader_bars} | |
| <div style="border-top:1px solid #eee;padding-top:12px;margin-top:4px"> | |
| <div style="font-size:11px;font-weight:700;color:#9ca3af;letter-spacing:1px; | |
| text-transform:uppercase;margin-bottom:8px">Reward Breakdown</div> | |
| {reward_rows} | |
| <div style="display:flex;justify-content:space-between;padding:8px 0; | |
| font-size:14px;font-weight:700"> | |
| <span>Total Reward</span> | |
| <span style="color:{'#2e7d32' if result.total_reward>0 else '#c62828'}"> | |
| {result.total_reward:+.2f} | |
| </span> | |
| </div> | |
| </div> | |
| </div> | |
| </div> | |
| <!-- SOURCES --> | |
| <div style="background:#fff;border-radius:14px;border:1px solid #e8ecf4; | |
| padding:20px 24px;margin-bottom:20px"> | |
| <div style="font-size:11px;font-weight:700;color:#9ca3af;letter-spacing:1px; | |
| text-transform:uppercase;margin-bottom:14px"> | |
| Evidence Sources ({len(scenario['sources'])} found) | |
| </div> | |
| {sources_html} | |
| </div> | |
| {reasoning_html} | |
| <!-- EXPLANATION --> | |
| <div style="background:#fff;border-radius:14px;border:1px solid #e8ecf4; | |
| padding:20px 24px"> | |
| <div style="font-size:11px;font-weight:700;color:#9ca3af;letter-spacing:1px; | |
| text-transform:uppercase;margin-bottom:14px"> | |
| 📋 Full Reasoning & Explanation | |
| </div> | |
| <div style="background:#f8faff;border-radius:10px;padding:16px 20px"> | |
| {expl_html} | |
| </div> | |
| </div> | |
| </div> | |
| """ | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # Main pipeline (streaming generator) | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| def analyze(statement: str) -> Generator: | |
| """ | |
| Difficulty is NOT a UI input. | |
| The UI is a demo tool; evaluation difficulty is controlled exclusively | |
| by the backend API (/reset?difficulty=...) and inference.py. | |
| DataCollector always uses 'medium' here — it only affects evidence | |
| retrieval depth, not grading. | |
| """ | |
| statement = statement.strip() | |
| if not statement: | |
| yield "<p style='color:#c62828;padding:20px'>⚠️ Please enter a statement to analyze.</p>" | |
| return | |
| # Stage 1 — Extract claims | |
| yield _progress_html("Extracting claims", 10, "detecting verifiable assertions…") | |
| claims = extract_claims(statement) | |
| if not claims: | |
| claims = [statement] | |
| claim_list = " • ".join(f"<em>{c[:60]}</em>" for c in claims) | |
| yield _progress_html("Searching sources", 30, | |
| f"found {len(claims)} claim(s): {claim_list[:120]}…") | |
| # Stage 2 — Collect evidence | |
| # Difficulty is fixed to "medium" here — the UI does NOT control evaluation logic. | |
| # To run a proper benchmark, use: python inference.py --benchmark | |
| try: | |
| req = CollectionRequest(content=statement, claims=claims, | |
| difficulty="medium") | |
| scenario = collector.collect(req) | |
| except Exception as e: | |
| yield f"<p style='color:#c62828;padding:20px'>❌ Evidence collection failed: {e}</p>" | |
| return | |
| n_src = len(scenario["sources"]) | |
| yield _progress_html("Running analysis", 65, | |
| f"fetched {n_src} source(s) — running moderation episode…") | |
| # Stage 3 — Run episode | |
| env = InformationIntegrityEnv(scenario=scenario, max_steps=20) | |
| obs = env.reset() | |
| per_claim_reasoning = None # populated by reasoning engine at decide step | |
| # Auto-agent: verify all claims → check all sources → decide | |
| for claim in obs.claims: | |
| try: | |
| obs, _, done, _ = env.step( | |
| Action(type="verify_claim", claim_id=claim.id, | |
| reasoning="auto-verify")) | |
| if done: | |
| break | |
| except Exception: | |
| pass | |
| if not env.done: | |
| for src in obs.available_sources: | |
| try: | |
| obs, _, done, _ = env.step( | |
| Action(type="check_source", source_id=src.id, | |
| reasoning="auto-check")) | |
| if done: | |
| break | |
| except Exception: | |
| pass | |
| if not env.done: | |
| # Use DeterministicReasoningEngine if available, else weighted fallback | |
| if _REASONING_AVAILABLE: | |
| try: | |
| pipeline = RetrievalPipeline() | |
| engine = DeterministicReasoningEngine() | |
| raw_sources = [ | |
| { | |
| "id": s.id, "title": s.title, "text": s.text, | |
| "url": s.url, "stance": s.stance, | |
| "reliability": s.reliability, "source_type": s.source_type, | |
| } | |
| for s in obs.available_sources | |
| ] | |
| claim_texts = [c.text for c in obs.claims] | |
| claim_results_map = pipeline.retrieve_for_all_claims(claim_texts, raw_sources) | |
| agg_decision, per_claim_reasoning = reason_over_claims(claim_results_map, engine) | |
| # Convert StructuredReasoning objects → dicts for the HTML builder | |
| per_claim_reasoning = {ct: r.to_dict() for ct, r in per_claim_reasoning.items()} | |
| # ── decision_engine: recalibrate each claim's confidence & decision ── | |
| de_inputs = [] | |
| for ct, r in per_claim_reasoning.items(): | |
| src_list = claim_results_map.get(ct, []) | |
| de_inputs.append({ | |
| "claim": ct, | |
| "status": "FALSE" if r["decision"] == "remove" | |
| else "TRUE" if r["decision"] == "allow" | |
| else "UNKNOWN", | |
| "confidence": r.get("evidence_score", 0.0), | |
| "supporting_sources": r["n_supporting"], | |
| "contradicting_sources": r["n_contradicting"], | |
| "neutral_sources": r["n_neutral"], | |
| "avg_source_reliability": ( | |
| sum(s.reliability for s in src_list) / len(src_list) | |
| if src_list else 0.5 | |
| ), | |
| }) | |
| de_result = make_moderation_decisions(de_inputs) | |
| # Map content decision back to env decision format | |
| _de_map = {"AUTO_REMOVE": "remove", "ALLOW": "allow", "FLAG_FOR_REVIEW": "flag"} | |
| decision = _de_map.get(de_result["content_decision"], agg_decision) | |
| # Inject decision_engine output into per_claim_reasoning for display | |
| for entry in de_result["per_claim"]: | |
| ct = entry["claim"] | |
| if ct in per_claim_reasoning: | |
| per_claim_reasoning[ct]["de_decision"] = entry["decision"] | |
| per_claim_reasoning[ct]["de_confidence"] = entry["final_confidence"] | |
| per_claim_reasoning[ct]["de_reason"] = entry["reason"] | |
| per_claim_reasoning[ct]["de_pattern"] = entry.get("pattern_matched") | |
| except Exception: | |
| per_claim_reasoning = None | |
| # Fallback to weighted ratio | |
| contra = sum(s.reliability for s in obs.available_sources if s.stance == "contradicting") | |
| supp = sum(s.reliability for s in obs.available_sources if s.stance == "supporting") | |
| total = contra + supp or 1.0 | |
| ratio = supp / total | |
| decision = "remove" if ratio < 0.25 else "flag" if ratio < 0.60 else "allow" | |
| else: | |
| per_claim_reasoning = None | |
| contra = sum(s.reliability for s in obs.available_sources if s.stance == "contradicting") | |
| supp = sum(s.reliability for s in obs.available_sources if s.stance == "supporting") | |
| total = contra + supp or 1.0 | |
| ratio = supp / total | |
| decision = "remove" if ratio < 0.25 else "flag" if ratio < 0.60 else "allow" | |
| try: | |
| obs, _, _, _ = env.step( | |
| Action(type="decide", decision=decision, | |
| reasoning="deterministic engine decision")) | |
| except Exception: | |
| pass | |
| else: | |
| per_claim_reasoning = None | |
| yield _progress_html("Complete", 95, "generating explanation…") | |
| # Stage 4 — Build result | |
| result = env.episode_result() | |
| reasoning = build_reasoning_from_episode( | |
| obs=obs, | |
| decision=result.decision or "unknown", | |
| episode_id=env._episode_id, | |
| difficulty=scenario["difficulty"], | |
| ) | |
| explanation = explainer.generate_explanation(reasoning) | |
| # Use engine's per_claim_reasoning if captured, else env's cached reasoning | |
| if per_claim_reasoning is None and env._last_reasoning: | |
| per_claim_reasoning = { | |
| ct: r.to_dict() for ct, r in env._last_reasoning.items() | |
| } | |
| yield build_result_html(statement, scenario, obs, result, explanation, | |
| per_claim_reasoning=per_claim_reasoning) | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # UI Layout | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| CSS = """ | |
| @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap'); | |
| body, .gradio-container { font-family: 'Inter', system-ui, sans-serif !important; background: #f0f4ff !important; } | |
| .gr-button-primary { background: linear-gradient(135deg,#4f8ef7,#7c6af7) !important; | |
| border:none !important; font-weight:700 !important; | |
| font-size:16px !important; padding:14px 36px !important; | |
| border-radius:12px !important; color:white !important; } | |
| .gr-button-primary:hover { opacity:.9 !important; transform:translateY(-1px); } | |
| textarea { font-size:15px !important; border-radius:12px !important; | |
| border:2px solid #e0e7ff !important; padding:14px !important; } | |
| textarea:focus { border-color:#4f8ef7 !important; box-shadow:0 0 0 3px rgba(79,142,247,.15) !important; } | |
| .gr-form { background:transparent !important; } | |
| .gr-box { background:transparent !important; border:none !important; box-shadow:none !important; } | |
| #component-0 { background: #f0f4ff !important; } | |
| """ | |
| EXAMPLES = [ | |
| "5G towers confirmed to spread COVID-19. Scientists reveal radiation activates coronavirus. Governments hiding the truth.", | |
| "Doctors confirm: drinking 3 cups of coffee daily prevents Alzheimer's in 100% of patients with zero side effects.", | |
| "New government report proves immigration increases violent crime by 40% in all affected regions. Multiple studies confirm.", | |
| "mRNA vaccines permanently alter human DNA and cause infertility according to multiple top doctors and researchers.", | |
| "There will be a national lockdown starting next week. Government sources confirmed mandatory quarantine for all cities.", | |
| "Eating chocolate every day reduces heart attack risk by 50% — scientists confirm in landmark study.", | |
| ] | |
| with gr.Blocks(title="Information Integrity Analyzer") as demo: | |
| gr.HTML(""" | |
| <div style="text-align:center;padding:40px 20px 20px;font-family:'Inter',sans-serif"> | |
| <div style="font-size:36px;margin-bottom:8px">🛡️</div> | |
| <h1 style="font-size:28px;font-weight:800;color:#1e2a4a;margin:0 0 8px"> | |
| Information Integrity Analyzer | |
| </h1> | |
| <p style="color:#6b7280;font-size:15px;max-width:520px;margin:0 auto"> | |
| Paste any statement or claim. The system automatically extracts assertions, | |
| searches real evidence sources, and delivers a moderation verdict with full explanation. | |
| </p> | |
| <p style="color:#9ca3af;font-size:12px;margin-top:8px"> | |
| Demo mode — for benchmarking across difficulty tiers run: | |
| <code>python inference.py --benchmark</code> | |
| </p> | |
| </div> | |
| """) | |
| with gr.Row(elem_id="main-row"): | |
| with gr.Column(scale=1, min_width=640): | |
| statement_box = gr.Textbox( | |
| label="", | |
| placeholder=( | |
| "Paste any statement, post, or claim here…\n\n" | |
| "e.g. \"5G towers confirmed to spread COVID-19. " | |
| "Governments hiding the truth.\"" | |
| ), | |
| lines=4, | |
| max_lines=8, | |
| show_label=False, | |
| ) | |
| analyze_btn = gr.Button( | |
| "🔍 Analyze Statement", | |
| variant="primary", | |
| ) | |
| gr.HTML("<div style='margin:8px 0 4px;font-size:12px;color:#9ca3af;font-weight:600;letter-spacing:.5px;text-transform:uppercase'>Try an example</div>") | |
| with gr.Row(): | |
| for ex_text in EXAMPLES[:3]: | |
| btn = gr.Button(ex_text[:45] + "…", size="sm", scale=1) | |
| btn.click(fn=lambda t=ex_text: t, outputs=[statement_box]) | |
| with gr.Row(): | |
| for ex_text in EXAMPLES[3:]: | |
| btn = gr.Button(ex_text[:45] + "…", size="sm", scale=1) | |
| btn.click(fn=lambda t=ex_text: t, outputs=[statement_box]) | |
| result_html = gr.HTML( | |
| value="<div style='padding:32px;text-align:center;color:#9ca3af;font-size:15px'>" | |
| "Results will appear here after analysis.</div>" | |
| ) | |
| analyze_btn.click( | |
| fn=analyze, | |
| inputs=[statement_box], | |
| outputs=[result_html], | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| show_error=True, | |
| css=CSS, | |
| theme=gr.themes.Soft( | |
| primary_hue="indigo", | |
| secondary_hue="purple", | |
| neutral_hue="slate", | |
| font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"], | |
| ), | |
| ) | |