# app.py # Slop Detector # Gradio app # 24-02-2026 # # EVERNOTE: # https://share.evernote.com/note/0fb9b438-7842-4eff-a93f-ba0850e6ae83 # # F:\DATA SCIENCE\MIJN DATA SCIENCE PROJECTS\FAKE NEWS DETECTOR - LOCAL LLM - SIRAJ RAVAL FEB 2026\SlopShield-main\SlopShield-PYTHON\GRADIO_APP # app.py # Gradio app for automated slop detection (Hugging Face Spaces ready). # # ✅ Features: # - User can input a URL OR paste text # - Extracts main content (trafilatura preferred, BeautifulSoup fallback) # - Calls an OpenAI "mini" model (default: gpt-4o-mini) using Structured Outputs (JSON Schema) # - Displays results neatly (score, subscores, contributions, interpretation, radar chart) # - Allows downloading a Markdown (.md) report and a PDF (.pdf) report # # --- HF Spaces setup notes --- # 1) Add an environment variable in your Space: # OPENAI_API_KEY = "..." # 2) Recommended requirements.txt: # gradio # openai # requests # trafilatura # beautifulsoup4 # lxml # matplotlib # reportlab # # OpenAI docs referenced for Structured Outputs + model listing: # - Structured Outputs: https://developers.openai.com/api/docs/guides/structured-outputs/ [oai_citation:0‡OpenAI Developers](https://developers.openai.com/api/docs/guides/structured-outputs/?utm_source=chatgpt.com) # - Models (incl. gpt-4o-mini): https://developers.openai.com/api/docs/models [oai_citation:1‡OpenAI Developers](https://developers.openai.com/api/docs/models?utm_source=chatgpt.com) # - gpt-4o-mini model page: https://developers.openai.com/api/docs/models/gpt-4o-mini [oai_citation:2‡OpenAI Developers](https://developers.openai.com/api/docs/models/gpt-4o-mini?utm_source=chatgpt.com) # - Responses API: https://platform.openai.com/docs/api-reference/responses [oai_citation:3‡platform.openai.com](https://platform.openai.com/docs/api-reference/responses?utm_source=chatgpt.com) # pip install -r requirements.txt --user import os import re import json import math import time import textwrap import urllib.parse from dataclasses import dataclass from typing import Optional, Dict, Any, Tuple, List import requests import gradio as gr # Optional extraction libs try: import trafilatura except Exception: trafilatura = None try: from bs4 import BeautifulSoup except Exception: BeautifulSoup = None import matplotlib.pyplot as plt from reportlab.lib.pagesizes import letter from reportlab.lib.styles import getSampleStyleSheet from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Preformatted from reportlab.lib.units import inch from openai import OpenAI # ----------------------------- # Config # ----------------------------- DEFAULT_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini") MAX_CHARS_SENT_TO_LLM = int(os.getenv("MAX_CHARS_SENT_TO_LLM", "35000")) # safety for context HTTP_TIMEOUT = int(os.getenv("HTTP_TIMEOUT", "20")) # Output dir for reports and radar chart (works on Windows and Linux) _OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "slop_output") os.makedirs(_OUTPUT_DIR, exist_ok=True) # Preset URLs the user can choose from (DEV_LOG examples) DEFAULT_URL_CHOICES = [ ("Custom — enter your own URL below", ""), ("CNN Home", "https://www.cnn.com/"), ("CNN Politics", "https://www.cnn.com/politics"), ("CNN — US-Iran strike article", "https://edition.cnn.com/2026/02/19/politics/us-iran-strike-options-trump-military"), ("CNN — China AI Seedance", "https://www.cnn.com/2026/02/20/china/china-ai-seedance-intl-hnk-dst"), ("MattsWorld101 — SEO examples", "https://mattsworld101.com/examples-of-seo/"), ("Scitechtalk — Genealogy", "http://www.scitechtalk.org/UITGEBREIDE_GENEALOGIE_VAN%20_SERVAAS_BOURS/HTu1-10.html"), ("Scitechtalk — arXiv aggregator", "http://scitechtalk.org/ARXIV_AGGREGATOR/index.html"), ("arXiv — paper abs/2410.14255", "https://arxiv.org/abs/2410.14255"), ("Dumpert", "https://www.dumpert.nl/"), ("Medium — P vs NP of AI", "https://medium.com/data-and-beyond/the-p-vs-np-of-ai-why-reasoning-is-mathematically-impossible-for-a-decoder-ee440f1d27ce"), ("Medium — Creativity vector hallucination", "https://medium.com/data-and-beyond/i-extracted-a-creativity-vector-from-gpt-it-was-a-hallucination-95a033fb890a"), ("Medium — Topology of matrix multiplication", "https://medium.com/data-and-beyond/the-topology-of-matrix-multiplication-why-your-ai-is-just-folding-space-cf8e408f2c91"), ] UA = ( "Mozilla/5.0 (X11; Linux x86_64) " "AppleWebKit/537.36 (KHTML, like Gecko) " "Chrome/120.0 Safari/537.36 SlopDetector/1.0" ) # ----------------------------- # Helpers # ----------------------------- def clamp01(x: float) -> float: return max(0.0, min(1.0, float(x))) def safe_slug(s: str, max_len: int = 60) -> str: s = (s or "").strip().lower() s = re.sub(r"https?://", "", s) s = re.sub(r"[^a-z0-9]+", "-", s).strip("-") if not s: s = "slop-report" return s[:max_len].rstrip("-") def now_ts() -> str: return time.strftime("%Y%m%d-%H%M%S") def infer_title_from_text(text: str) -> str: # simple heuristic: first non-empty line (trim) for line in (text or "").splitlines(): line = line.strip() if len(line) >= 8: return line[:120] return "Untitled" def compute_interpretation(slop_score_0_100: float) -> str: # Interprets the 0–100 score; user can normalize by /100 if desired. s = slop_score_0_100 if s <= 5: band = "Extremely Low Slop" desc = "Meaning-dense, highly specific, minimal repetition/templating." elif s <= 15: band = "Very Low Slop" desc = "High information density; only mild stylistic templates." elif s <= 30: band = "Low Slop" desc = "Mostly meaning-driven, with some rhetorical repetition or structure." elif s <= 45: band = "Mild–Moderate Slop" desc = "Noticeable templating and/or generic framing; still contains substance." elif s <= 60: band = "Moderate Slop" desc = "Substantial filler/templating; reduced specificity; repetition noticeable." elif s <= 75: band = "High Slop" desc = "Strong low-value signals: repetition, template voice, low specificity." elif s <= 90: band = "Very High Slop" desc = "Predominantly template/filler; weak grounding; attention/SEO patterns likely." else: band = "Extreme Slop" desc = "Near-pure filler or spam-like content; minimal meaningful information." return f"**{band}** — {desc}" def weighted_contributions(result: Dict[str, Any]) -> Dict[str, float]: # Uses the canonical weights from your spec. info_density = clamp01(result.get("info_density", 0.0)) redundancy = clamp01(result.get("redundancy", 0.0)) template = clamp01(result.get("template_markers", 0.0)) incoherence = clamp01(result.get("incoherence", 0.0)) monetization = clamp01(result.get("monetization", 0.0)) contrib = { "info_density_deficit": 0.30 * (1.0 - info_density), "redundancy": 0.30 * redundancy, "template_markers": 0.20 * template, "incoherence": 0.10 * incoherence, "monetization": 0.10 * monetization, } # normalized sum should equal slop (0..1) if model followed formula contrib["slop_normalized_sum"] = sum(contrib.values()) contrib["slop_score_0_100_sum"] = 100.0 * contrib["slop_normalized_sum"] return contrib def make_radar_chart(subscores: Dict[str, float], out_path: str) -> str: labels = ["info_density", "redundancy", "template_markers", "incoherence", "monetization"] values = [clamp01(subscores.get(k, 0.0)) for k in labels] # Radar chart setup angles = [n / float(len(labels)) * 2 * math.pi for n in range(len(labels))] angles += angles[:1] vals = values + values[:1] plt.figure(figsize=(6, 6)) ax = plt.subplot(111, polar=True) ax.set_theta_offset(math.pi / 2) ax.set_theta_direction(-1) plt.xticks(angles[:-1], labels) ax.set_rlabel_position(0) plt.yticks([0.25, 0.5, 0.75], ["0.25", "0.50", "0.75"], alpha=0.7) plt.ylim(0, 1) # Do not set explicit colors (per system guidance) ax.plot(angles, vals, linewidth=2) ax.fill(angles, vals, alpha=0.15) plt.title("Subscores Radar (0–1)", y=1.08) plt.tight_layout() plt.savefig(out_path, dpi=160) plt.close() return out_path # ----------------------------- # Webpage extraction # ----------------------------- def normalize_url(url: str) -> str: """Ensure URL has a scheme (default https://).""" url = (url or "").strip() if not url: return url if not url.startswith(("http://", "https://")): url = "https://" + url return url def fetch_url(url: str) -> Tuple[str, str]: """Return (final_url, html).""" url = normalize_url(url) headers = {"User-Agent": UA} resp = requests.get(url, headers=headers, timeout=HTTP_TIMEOUT, allow_redirects=True) resp.raise_for_status() final_url = resp.url html = resp.text return final_url, html def extract_main_text(url: str) -> Tuple[str, str, str]: """ Returns (final_url, extracted_text, extraction_method). """ url = normalize_url(url) final_url, html = fetch_url(url) if trafilatura is not None: try: downloaded = trafilatura.extract( html, include_comments=False, include_tables=False, include_formatting=False, url=final_url, ) if downloaded and len(downloaded.strip()) > 200: return final_url, downloaded.strip(), "trafilatura" except Exception: pass # Fallback: BeautifulSoup get_text if BeautifulSoup is not None: soup = BeautifulSoup(html, "lxml") if "lxml" in globals() else BeautifulSoup(html, "html.parser") # Remove scripts/styles for tag in soup(["script", "style", "noscript"]): tag.decompose() text = soup.get_text("\n") # Normalize whitespace lines = [ln.strip() for ln in text.splitlines()] lines = [ln for ln in lines if ln] cleaned = "\n".join(lines) cleaned = re.sub(r"\n{3,}", "\n\n", cleaned).strip() return final_url, cleaned, "beautifulsoup_fallback" # Last resort: raw html stripped stripped = re.sub(r"<[^>]+>", " ", html) stripped = re.sub(r"\s+", " ", stripped).strip() return final_url, stripped, "regex_fallback" # ----------------------------- # OpenAI call (Structured Outputs JSON Schema) # ----------------------------- SLOP_SCHEMA = { "name": "slop_score_output", "schema": { "type": "object", "additionalProperties": False, "properties": { "info_density": {"type": "number"}, "redundancy": {"type": "number"}, "template_markers": {"type": "number"}, "incoherence": {"type": "number"}, "monetization": {"type": "number"}, "slop_score": {"type": "number"}, "top_contributing_factors": { "type": "array", "items": {"type": "string"}, "minItems": 1, }, "confidence": {"type": "number"}, }, "required": [ "info_density", "redundancy", "template_markers", "incoherence", "monetization", "slop_score", "top_contributing_factors", "confidence", ], }, "strict": True, } def build_prompt(url: str, text: str) -> str: # Your prompt, adapted to accept either URL or pasted text. # We do NOT ask the model to add interpretation outside JSON; the app does that deterministically. return f""" You are given extracted main text from a webpage. WEBPAGE: {url if url else ""} TEXT: Read the text from webpage: {url if url else "(user-provided text)"} MAIN_TEXT: \"\"\" {text} \"\"\" Goal: Estimate Sloppiness (0–100). Definition: Sloppiness = degree to which text is low-information, generic, repetitive, templated, incoherent, or monetization-optimized rather than meaning-dense. Constraints: - Evaluate only intrinsic writing properties. - Ignore topic, politics, and site type. - Do not speculate beyond text evidence. Step 1 — Produce normalized subscores (0–1): - info_density: 1 = high specificity, 0 = generic. - redundancy: 1 = heavy repetition. - template_markers: 1 = strongly templated. - incoherence: 1 = incoherent. - monetization: 1 = heavy monetization cues. Step 2 — Compute score: slop_score = 100 * ( 0.30 * (1 - info_density) + 0.30 * redundancy + 0.20 * template_markers + 0.10 * incoherence + 0.10 * monetization ) Step 3 — Output ONLY valid JSON matching the provided schema. """.strip() def call_openai_slop(api_key: str, model: str, url: str, text: str, temperature: float) -> Dict[str, Any]: api_key = (api_key or "").strip() if not api_key: raise RuntimeError("Please enter your OpenAI API key above before running analysis.") client = OpenAI(api_key=api_key) # Trim text for safety trimmed = text[:MAX_CHARS_SENT_TO_LLM] prompt = build_prompt(url=url, text=trimmed) # Chat Completions API with Structured Outputs (JSON Schema) resp = client.chat.completions.create( model=model, messages=[ {"role": "system", "content": "You are a careful evaluator. Follow the schema exactly."}, {"role": "user", "content": prompt}, ], temperature=temperature, response_format={"type": "json_schema", "json_schema": SLOP_SCHEMA}, ) raw = (resp.choices[0].message.content or "").strip() if not raw: raise RuntimeError("Model returned empty content.") try: data = json.loads(raw) except Exception as e: raise RuntimeError(f"Model returned non-JSON or malformed JSON. Raw output:\n{raw}") from e # Clamp and sanity-check for k in ["info_density", "redundancy", "template_markers", "incoherence", "monetization", "confidence"]: data[k] = clamp01(data.get(k, 0.0)) # slop_score should be 0..100 data["slop_score"] = float(data.get("slop_score", 0.0)) data["slop_score"] = max(0.0, min(100.0, data["slop_score"])) # Ensure list exists if not isinstance(data.get("top_contributing_factors"), list): data["top_contributing_factors"] = [] return data # ----------------------------- # Report generation (MD + PDF) # ----------------------------- def format_report_markdown( url: str, title: str, extraction_method: str, text_preview: str, result: Dict[str, Any], ) -> str: contrib = weighted_contributions(result) slop = result["slop_score"] interp = compute_interpretation(slop) normalized = slop / 100.0 md = [] md.append(f"# Slop Detection Report") md.append("") md.append(f"- **Title (heuristic):** {title}") md.append(f"- **URL:** {url if url else '(user-provided text)'}") md.append(f"- **Extraction method:** {extraction_method}") md.append(f"- **Generated at:** {time.strftime('%Y-%m-%d %H:%M:%S')}") md.append("") md.append("## Overall Score") md.append("") md.append(f"- **slop_score (0–100):** {slop:.1f}") md.append(f"- **slop (0–1):** {normalized:.3f}") md.append(f"- **confidence (0–1):** {result.get('confidence', 0.0):.2f}") md.append("") md.append("### Interpretation") md.append("") md.append(interp) md.append("") md.append("## Subscores (0–1)") md.append("") md.append("| Subscore | Value |") md.append("|---|---:|") md.append(f"| info_density | {result['info_density']:.2f} |") md.append(f"| redundancy | {result['redundancy']:.2f} |") md.append(f"| template_markers | {result['template_markers']:.2f} |") md.append(f"| incoherence | {result['incoherence']:.2f} |") md.append(f"| monetization | {result['monetization']:.2f} |") md.append("") md.append("## Weighted Contribution Breakdown (normalized)") md.append("") md.append("| Term | Weight Contribution | Share |") md.append("|---|---:|---:|") total = contrib["slop_normalized_sum"] if contrib["slop_normalized_sum"] > 0 else 1.0 for key in ["info_density_deficit", "redundancy", "template_markers", "incoherence", "monetization"]: val = contrib[key] share = val / total md.append(f"| {key} | {val:.4f} | {share:.1%} |") md.append("") md.append("## Top Contributing Factors (model)") md.append("") for f in result.get("top_contributing_factors", [])[:10]: md.append(f"- {f}") md.append("") md.append("## Raw JSON Output (model)") md.append("") md.append("```json") md.append(json.dumps(result, ensure_ascii=False, indent=2)) md.append("```") md.append("") md.append("## Text Preview (first ~1200 chars after extraction)") md.append("") md.append("```") md.append(text_preview) md.append("```") md.append("") return "\n".join(md) def save_markdown(md_text: str, base_slug: str) -> str: path = os.path.join(_OUTPUT_DIR, f"slop_report_{base_slug}_{now_ts()}.md") with open(path, "w", encoding="utf-8") as f: f.write(md_text) return path def save_pdf(md_text: str, base_slug: str) -> str: path = os.path.join(_OUTPUT_DIR, f"slop_report_{base_slug}_{now_ts()}.pdf") doc = SimpleDocTemplate(path, pagesize=letter, rightMargin=54, leftMargin=54, topMargin=54, bottomMargin=54) styles = getSampleStyleSheet() story = [] # Convert markdown-ish to simple paragraphs # Keep it robust: strip heavy markdown and preserve code blocks as Preformatted. lines = md_text.splitlines() in_code = False code_buf = [] def flush_code(): nonlocal code_buf if code_buf: story.append(Preformatted("\n".join(code_buf), styles["Code"])) story.append(Spacer(1, 0.15 * inch)) code_buf = [] for ln in lines: if ln.strip().startswith("```"): if not in_code: in_code = True code_buf = [] else: in_code = False flush_code() continue if in_code: code_buf.append(ln.rstrip("\n")) continue # headings if ln.startswith("# "): story.append(Paragraph(ln[2:].strip(), styles["Title"])) story.append(Spacer(1, 0.15 * inch)) elif ln.startswith("## "): story.append(Paragraph(ln[3:].strip(), styles["Heading2"])) story.append(Spacer(1, 0.10 * inch)) elif ln.startswith("### "): story.append(Paragraph(ln[4:].strip(), styles["Heading3"])) story.append(Spacer(1, 0.08 * inch)) elif ln.strip().startswith("- "): story.append(Paragraph("• " + ln.strip()[2:], styles["BodyText"])) elif ln.strip() == "": story.append(Spacer(1, 0.08 * inch)) else: # light markdown bold -> remove ** for PDF clean = ln.replace("**", "") story.append(Paragraph(clean, styles["BodyText"])) if in_code: flush_code() doc.build(story) return path # ----------------------------- # Gradio pipeline # ----------------------------- @dataclass class AnalysisInputs: api_key: str url: str pasted_text: str model: str temperature: float def analyze(inputs: AnalysisInputs) -> Tuple[str, Dict[str, Any], str, str, str]: url = (inputs.url or "").strip() pasted_text = (inputs.pasted_text or "").strip() if not url and not pasted_text: raise ValueError("Please provide either a URL or paste text to analyze.") extraction_method = "user_text" final_url = normalize_url(url) if url else "" text = pasted_text if url and not pasted_text: final_url, text, extraction_method = extract_main_text(url) # Basic title heuristic title = infer_title_from_text(text) base_slug = safe_slug(final_url or title) # Make a preview preview = text[:1200].strip() if len(text) > 1200: preview += "\n\n…(truncated preview)…" # Call OpenAI (API key from user input) result = call_openai_slop( api_key=inputs.api_key or "", model=inputs.model or DEFAULT_MODEL, url=final_url, text=text, temperature=float(inputs.temperature), ) # Build UI markdown summary interp = compute_interpretation(result["slop_score"]) normalized = result["slop_score"] / 100.0 contrib = weighted_contributions(result) summary_md = f""" ## Results **slop_score (0–100):** `{result["slop_score"]:.1f}` **slop (0–1):** `{normalized:.3f}` **confidence (0–1):** `{result.get("confidence", 0.0):.2f}` ### Interpretation {interp} ### Subscores (0–1) - info_density: `{result["info_density"]:.2f}` - redundancy: `{result["redundancy"]:.2f}` - template_markers: `{result["template_markers"]:.2f}` - incoherence: `{result["incoherence"]:.2f}` - monetization: `{result["monetization"]:.2f}` ### Dominant contributors (weighted shares) - redundancy: `{(contrib["redundancy"]/contrib["slop_normalized_sum"] if contrib["slop_normalized_sum"] else 0):.1%}` - template_markers: `{(contrib["template_markers"]/contrib["slop_normalized_sum"] if contrib["slop_normalized_sum"] else 0):.1%}` - info_density_deficit: `{(contrib["info_density_deficit"]/contrib["slop_normalized_sum"] if contrib["slop_normalized_sum"] else 0):.1%}` - incoherence: `{(contrib["incoherence"]/contrib["slop_normalized_sum"] if contrib["slop_normalized_sum"] else 0):.1%}` - monetization: `{(contrib["monetization"]/contrib["slop_normalized_sum"] if contrib["slop_normalized_sum"] else 0):.1%}` ### Top contributing factors (model) {chr(10).join([f"- {x}" for x in result.get("top_contributing_factors", [])[:8]]) if result.get("top_contributing_factors") else "- (none provided)"} ### Extraction preview
Show extracted text preview {preview}
""".strip() # Radar chart radar_path = os.path.join(_OUTPUT_DIR, f"radar_{base_slug}_{now_ts()}.png") make_radar_chart( { "info_density": result["info_density"], "redundancy": result["redundancy"], "template_markers": result["template_markers"], "incoherence": result["incoherence"], "monetization": result["monetization"], }, radar_path, ) # Reports report_md = format_report_markdown( url=final_url, title=title, extraction_method=extraction_method, text_preview=preview, result=result, ) md_path = save_markdown(report_md, base_slug) pdf_path = save_pdf(report_md, base_slug) return summary_md, result, radar_path, md_path, pdf_path # ----------------------------- # Gradio UI # ----------------------------- def run_analysis(api_key: str, url: str, pasted_text: str, model: str, temperature: float): inputs = AnalysisInputs(api_key=api_key, url=url, pasted_text=pasted_text, model=model, temperature=temperature) return analyze(inputs) with gr.Blocks(title="Automated Slop Detection") as demo: gr.Markdown( "# Automated Slop Detection\n" "Analyze a webpage (URL) or pasted text and estimate **Sloppiness** with subscores.\n\n" "**Tip:** For best results, analyze a single article page (not a homepage/feed)." ) api_key_in = gr.Textbox( label="OpenAI API Key (required)", type="password", placeholder="sk-...", info="Enter your OpenAI API key to run analysis. It is not stored.", ) url_preset_in = gr.Dropdown( label="Choose a preset URL (or Custom to enter your own)", choices=[(label, url) for label, url in DEFAULT_URL_CHOICES], value="", allow_custom_value=False, ) url_in = gr.Textbox( label="URL (optional — used when preset is Custom)", value="", placeholder="https://example.com/article", lines=1, ) text_in = gr.Textbox( label="Paste text (optional)", placeholder="Paste extracted main text here (leave URL empty if using pasted text).", lines=10, ) with gr.Row(): model_in = gr.Textbox(label="OpenAI model", value=DEFAULT_MODEL) temp_in = gr.Slider(label="Temperature", minimum=0.0, maximum=1.0, value=0.0, step=0.05, info="Set to 0 for stable, deterministic results.") analyze_btn = gr.Button("Analyze", variant="primary") gr.Markdown("---") out_md = gr.Markdown(label="Summary") out_json = gr.JSON(label="Model JSON output (schema)") out_plot = gr.Image(label="Subscores radar chart", type="filepath") with gr.Row(): out_md_file = gr.File(label="Download Markdown report (.md)") out_pdf_file = gr.File(label="Download PDF report (.pdf)") def _on_click(api_key, url_preset, url_custom, text, model, temp): url = (url_preset or "").strip() or (url_custom or "").strip() summary_md, result_json, radar_path, md_path, pdf_path = run_analysis(api_key, url, text, model, temp) return summary_md, result_json, radar_path, md_path, pdf_path analyze_btn.click( _on_click, inputs=[api_key_in, url_preset_in, url_in, text_in, model_in, temp_in], outputs=[out_md, out_json, out_plot, out_md_file, out_pdf_file], ) gr.Markdown( "### Notes\n" "- **slop_score (0–100)** is the scaled score. Divide by 100 for normalized slop in **[0,1]**.\n" "- The app generates its own interpretation from slop_score bands to keep the model output strictly JSON.\n" "- OpenAI usage and billing: [platform.openai.com/usage](https://platform.openai.com/usage)\n" ) if __name__ == "__main__": demo.launch() # python app.py # =========================================================================================