Initial commit

app.py

@@ -0,0 +1,750 @@
+# 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
+<details>
+<summary>Show extracted text preview</summary>
+
+{preview}
+
+</details>
+""".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
+
+# =========================================================================================
+

requirements.txt

@@ -0,0 +1,8 @@
+gradio
+openai
+requests
+trafilatura
+beautifulsoup4
+lxml
+matplotlib
+reportlab