Upload 13 files

README.md

@@ -1,15 +1,71 @@
 ---
-title: AI Writing Suite
-emoji: 🏢
-colorFrom: pink
+title: CS AI Writing Suite
+emoji: ✨
+colorFrom: indigo
 colorTo: pink
 sdk: gradio
-sdk_version: 6.28.0
-python_version: '3.12'
+sdk_version: 5.49.1
+python_version: "3.10"
 app_file: app.py
-pinned: false
+pinned: true
 license: apache-2.0
-short_description: Smart_AI
+short_description: Detect AI writing and humanize it, Word layout kept
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CS AI Writing Suite — by CS Software Solutions
+
+One Space, three tools in a navigation bar:
+
+| Tab | What it does |
+|---|---|
+| 🚀 **Smart Humanize** | Detector + humanizer together: scores every sentence with the AI detector, rewrites **only the flagged sentences**, re-checks, and repeats until the target AI % or the pass limit is reached. |
+| 🔍 **AI Detector** | Highlighted AI-likelihood view (cyan = high, purple = moderate) + PDF report. |
+| ✨ **Humanizer** | Full paraphrase of every eligible paragraph (Parrot T5), with the detector score before/after. |
+| 👤 **Account** | Sign in / sign up / profile. |
+| 🛡️ **Admin** | Visible only to emails listed in `ADMIN_EMAILS`. |
+
+Shortcut buttons link the tools: *Humanize this text →* (Detector → Smart Humanize) and
+*Send result to AI Detector →* (Humanizer → Detector).
+
+## Access rules
+
+- **Paste text** — open to everyone, no sign-in (limit `MAX_PASTE_WORDS`, default 6000).
+- **Document upload** (.docx / .pdf / .txt) — requires a free account. Upload tabs show a lock card
+  until the user signs in, and the server also rejects uploads from signed-out sessions.
+
+## Setup (Settings → Variables and secrets)
+
+| Name | Type | Purpose |
+|---|---|---|
+| `HF_TOKEN` | secret | Read token of an account that accepted the terms of the gated `coai/roberta-ai-detector-v2` model |
+| `ADMIN_EMAILS` | secret | Comma-separated admin emails |
+| `APP_NAME` | variable (optional) | Header title (default "CS AI Writing Suite") |
+| `REPORT_BRAND` | variable (optional) | Header text on PDF report pages |
+| `MAX_PASTE_WORDS` | variable (optional) | Paste limit |
+| `DETECTOR_MODEL`, `PARROT_MODEL` | variable (optional) | Swap models |
+
+Hardware: **ZeroGPU**. Enable **Persistent storage** so the user database (`/data/users.db`)
+survives restarts.
+
+## Files
+
+- `app.py` — UI, navigation bar, sign-in gating, handlers
+- `smart.py` — detect → rewrite flagged sentences → re-check loop (in-place Word editing)
+- `detector.py` — AI detector + PDF/HTML report
+- `docx_report.py` — Word highlighting + LibreOffice conversion
+- `humanizer.py` — Parrot paraphraser
+- `auth.py` — accounts and admin
+- `packages.txt` — LibreOffice + fonts (Word → PDF reports)
+- `logo.png`, `favicon.png`
+
+## Smart Humanize details
+
+- Sentences with P(AI) ≥ the moderate threshold (default 0.50) are rewritten; each later pass uses
+  slightly bolder variation.
+- A rewrite is rejected (original kept) if it drops numbers or changes length drastically; dropped
+  citations like `[12]` or `(Kumar et al., 2021)` are re-attached.
+- In Word files only the flagged sentence's text is replaced; the rest of the paragraph keeps its
+  formatting. Citation fields, hyperlinks and superscript/subscript runs are never edited — the prose
+  around them is rewritten instead.
+
+Scores are indicators from an open-source detector and will differ from Turnitin, GPTZero, etc.

app.py

@@ -0,0 +1,656 @@
+"""
+CS AI Writing Suite — one Space, three tools behind a navigation bar:
+
+  🚀 Smart Humanize  detector finds AI-flagged sentences → humanizer rewrites only those → re-check (loop)
+  🔍 AI Detector     highlighted AI-likelihood PDF report (RoBERTa detector)
+  ✨ Humanizer       Parrot-T5 paraphraser (whole text / whole document)
+
+Access rule: pasting text is open to everyone; uploading a document requires sign-in.
+"""
+import html
+import os
+import re
+
+import gradio as gr
+
+import humanizer as H          # loads the paraphraser (kept on CPU until a GPU call)
+import detector as D           # loads the detector (+ starts LibreOffice fetch)
+import smart as S
+import auth as A
+from humanizer import BRAND, RAINBOW, LOGO_SRC, FAVICON_SRC, FAVICON_PATH, MODES, OUT_DIR
+
+APP_NAME = os.getenv("APP_NAME", "CS AI Writing Suite")
+SITE_URL = "https://cssoftwaresolutions.in"
+
+
+# =====================================================================
+# Shared UI helpers
+# =====================================================================
+def _stats_gauge(title, pct, caption, good_low=True):
+    if pct is None:
+        return H._gauge(title, None, caption)
+    return H._gauge(title, pct, caption, invert=not good_low)
+
+
+def suite_panel(ai_before, ai_after, original, revised):
+    sim = H.similarity_to_source(original, revised)
+    changed = H.words_changed(original, revised)
+    return f"""
+    <div class="cs-scores">
+      {_stats_gauge("AI score · before", ai_before, "RoBERTa detector on your original")}
+      {_stats_gauge("AI score · after", ai_after, "RoBERTa detector on the rewritten text")}
+      {H._gauge("Similarity to source", sim, "Word n-gram overlap with your original")}
+      {H._gauge("Vocabulary changed", changed, "Share of new wording", fixed_color=BRAND["navy"])}
+    </div>
+    <div class="cs-disclaimer">
+      <b>Indicators only.</b> The AI score comes from an open-source detector and will differ from Turnitin,
+      GPTZero or other tools. Similarity is measured against your own text, not internet or journal databases.
+      Always review the output for meaning, technical terms and citations before use.
+    </div>"""
+
+
+EMPTY = """<div class="cs-scores cs-empty"><div>Scores appear here after processing.</div></div>"""
+
+
+def _locked(what):
+    return (f'<div class="cs-lock"><div class="cs-lock-ico">🔒</div>'
+            f'<div class="cs-lock-t">Sign in to upload {what}</div>'
+            f'<div class="cs-lock-s">Document upload needs a free account. '
+            f'Pasting text works without signing in — use the <b>Paste text</b> tab.</div></div>')
+
+
+def _userbar(user):
+    if not user:
+        return '<div class="cs-userbar"><span>👤 Guest — paste text freely · sign in to upload documents</span></div>'
+    return (f'<div class="cs-userbar"><span>👋 <b>{html.escape(user["name"])}</b> '
+            f'<small>({html.escape(user["email"])})</small></span></div>')
+
+
+def _profile(user):
+    if not user:
+        return ""
+    with A._db() as con:
+        row = con.execute("SELECT created, last_login, runs FROM users WHERE email=?", (user["email"],)).fetchone()
+    created, last, runs = row or ("", "", 0)
+    return (f'<div class="cs-auth-title">My account</div>'
+            f'<div class="cs-prof"><div><span>Name</span><b>{html.escape(user["name"])}</b></div>'
+            f'<div><span>Email</span><b>{html.escape(user["email"])}</b></div>'
+            f'<div><span>Member since</span><b>{(created or "")[:10]}</b></div>'
+            f'<div><span>Document runs</span><b>{runs or 0}</b></div></div>')
+
+
+# =====================================================================
+# Handlers — status panel streaming via H._run_live
+# =====================================================================
+def _stream(core, args, n, idx, user=None, need_login=False):
+    if need_login:
+        A._require(user)
+        A._count_run(user)
+    for frame in H._run_live(core, args, n, idx):
+        yield frame
+
+
+# ---------------- Smart Humanize ----------------
+def _smart_result(res, hi, mod, text_mode):
+    b, a = res["before"], res["after"]
+    log = "<br>".join(html.escape(x) for x in res["log"])
+    msg = (f"✅ **Done** — AI score {b['pct']}% → {a['pct']}%.\n\n{log}"
+           + (f"\n\n{res['note']}" if res["note"] else ""))
+    preview = D.build_html(res["blocks"], a, hi, mod)
+    panel = suite_panel(b["pct"], a["pct"], res["orig"], res["new"])
+    out = [H.status_done(msg), preview, panel, res["path"], H.download_button(res["path"])]
+    if text_mode:
+        out.insert(1, res["text"])
+    return tuple(out)
+
+
+def _smart_text_core(text, target, passes, temp, mode, hi, mod, rep):
+    text = (text or "").strip()
+    if not text:
+        raise gr.Error("Please paste some text.")
+    if len(text.split()) > H.MAX_PASTE_WORDS:
+        raise gr.Error(f"Please keep pasted text under {H.MAX_PASTE_WORDS:,} words, or sign in and upload a .docx.")
+    res = S.smart_text(text, target, passes, temp, mode, hi, mod, rep)
+    return _smart_result(res, hi, mod, True)
+
+
+def _smart_docx_core(path, target, passes, temp, mode, hi, mod, rep):
+    if not path or not str(path).lower().endswith(".docx"):
+        raise gr.Error("Please upload a Word (.docx) file.")
+    res = S.smart_docx(path, target, passes, temp, mode, hi, mod, rep)
+    return _smart_result(res, hi, mod, False)
+
+
+def smart_text(text, target, passes, temp, mode, hi, mod, user):
+    yield from _stream(_smart_text_core, (text, target, passes, temp, mode, hi, mod), 6, 0)
+
+
+def smart_docx(path, target, passes, temp, mode, hi, mod, user):
+    yield from _stream(_smart_docx_core, (path, target, passes, temp, mode, hi, mod), 5, 0, user, True)
+
+
+# ---------------- Detector ----------------
+def _det_core(file, text, hi, mod, rep):
+    if mod >= hi:
+        raise gr.Error("Moderate threshold must be below the high threshold.")
+    page, pdf = D.run(file, text, hi, mod, rep)
+    return H.status_done("✅ **Report ready** — download the PDF below."), page, pdf
+
+
+def detect_text(text, hi, mod, user):
+    if not (text or "").strip():
+        raise gr.Error("Please paste some text.")
+    if len(text.split()) > H.MAX_PASTE_WORDS:
+        raise gr.Error(f"Please keep pasted text under {H.MAX_PASTE_WORDS:,} words, or sign in and upload a file.")
+    yield from _stream(_det_core, (None, text, hi, mod), 3, 0)
+
+
+def detect_file(file, hi, mod, user):
+    if not file:
+        A._require(user)
+        raise gr.Error("Please upload a .docx, .pdf or .txt file.")
+    yield from _stream(_det_core, (file, None, hi, mod), 3, 0, user, True)
+
+
+# ---------------- Humanizer ----------------
+def _hum_text_core(text, temp, min_words, mode, rep):
+    out_text, path, dl, summary, _ = H._text_core(text, temp, min_words, mode, rep)
+    rep(0.97, "Checking AI score before/after")
+    panel = suite_panel(S.detector_pct_text(text), S.detector_pct_text(out_text), text, out_text)
+    return out_text, path, dl, H.status_done(summary), panel
+
+
+def _hum_docx_core(path, temp, min_words, mode, rep):
+    out, dl, summary, _, preview = H._docx_core(path, temp, min_words, mode, rep)
+    rep(0.97, "Checking AI score before/after")
+    from docx import Document
+    orig = "\n".join(p.text for p in Document(path).paragraphs)
+    new = "\n".join(p.text for p in Document(out).paragraphs)
+    panel = suite_panel(S.detector_pct_docx(path), S.detector_pct_docx(out), orig, new)
+    return out, dl, H.status_done(summary), panel, preview
+
+
+def humanize_text(text, temp, min_words, mode, user):
+    if not (text or "").strip():
+        raise gr.Error("Please paste some text to paraphrase.")
+    yield from _stream(_hum_text_core, (text, temp, min_words, mode), 5, 3)
+
+
+def humanize_docx(path, temp, min_words, mode, user):
+    yield from _stream(_hum_docx_core, (path, temp, min_words, mode), 5, 2, user, True)
+
+
+# =====================================================================
+# Auth events
+# =====================================================================
+LOCKS, OPENS = [], []   # filled while building the UI
+
+
+def _auth_updates(user, msg=""):
+    admin = A.is_admin(user)
+    signed = bool(user)
+    base = [
+        user,
+        gr.update(visible=not signed),            # auth_view
+        gr.update(visible=signed),                # profile_view
+        _profile(user),                           # profile_html
+        _userbar(user),                           # user_bar
+        msg,                                      # auth_msg
+        gr.update(visible=admin),                 # admin_tab
+        A.admin_stats(user) if admin else "",
+        A.admin_table(user) if admin else None,
+        gr.update(visible=not signed),            # top sign-in button
+        gr.update(visible=signed),                # top log-out button
+    ]
+    base += [gr.update(visible=not signed) for _ in LOCKS]
+    base += [gr.update(visible=signed) for _ in OPENS]
+    return base
+
+
+def do_login(email, password):
+    user, err = A.check_user(email, password)
+    if err:
+        return [None, gr.update(), gr.update(), "", _userbar(None), A._msg(err)] + [gr.update()] * (5 + 2 * len(LOCKS))
+    return _auth_updates(user, A._msg(f"Welcome back, {html.escape(user['name'])}! Upload is now unlocked.", ok=True))
+
+
+def do_signup(name, email, password, confirm):
+    user, err = A.create_user(name, email, password, confirm)
+    if err:
+        return [None, gr.update(), gr.update(), "", _userbar(None), A._msg(err)] + [gr.update()] * (5 + 2 * len(LOCKS))
+    return _auth_updates(user, A._msg("Account created — document upload is now unlocked.", ok=True))
+
+
+def do_logout():
+    return _auth_updates(None, A._msg("You have been logged out.", ok=True))
+
+
+# =====================================================================
+# UI
+# =====================================================================
+CSS = f"""
+:root {{ --cs-navy:{BRAND['navy']}; --cs-purple:{BRAND['purple']}; --cs-magenta:{BRAND['magenta']};
+  --cs-sky:{BRAND['sky']}; --cs-rainbow:{RAINBOW}; }}
+.gradio-container {{ max-width:1200px !important; margin:0 auto !important;
+  font-family:'Poppins', ui-sans-serif, system-ui, sans-serif !important; }}
+body, .gradio-container {{ background:#f6f7fb !important; }}
+footer, #huggingface-space-header, .show-api {{ display:none !important; }}
+
+/* header */
+.cs-header {{ display:flex; align-items:center; gap:20px; padding:18px 24px; border-radius:20px 20px 0 0;
+  background:#fff; box-shadow:0 8px 30px rgba(7,34,139,.08); }}
+.cs-header img {{ width:74px; height:74px; border-radius:50%; flex:none; box-shadow:0 4px 14px rgba(0,0,0,.12); }}
+.cs-header h1 {{ margin:0; font-size:27px; font-weight:800; color:var(--cs-navy); letter-spacing:-.3px; line-height:1.15; }}
+.cs-header h1 span {{ color:var(--cs-magenta) !important; }}
+.cs-header p {{ margin:4px 0 0; color:#555; font-size:14px; }}
+@media (max-width:640px) {{ .cs-header {{ flex-direction:column; text-align:center; }} .cs-header h1 {{ font-size:22px; }} }}
+
+/* account strip under header */
+#cs-strip {{ background:#fff; border-radius:0 0 20px 20px; padding:4px 18px 8px; margin-top:-16px !important;
+  box-shadow:0 8px 30px rgba(7,34,139,.08); position:relative; align-items:center; }}
+#cs-strip::before {{ content:""; position:absolute; left:0; right:0; top:0; height:4px; background:var(--cs-rainbow); }}
+.cs-userbar {{ display:flex; align-items:center; padding:8px 2px; color:#444; font-size:14px; }}
+.cs-userbar small {{ color:#888; }}
+.cs-topbtn {{ max-width:150px !important; min-width:110px !important; }}
+
+/* navigation bar (top-level tabs) */
+#cs-nav > .tab-wrapper, #cs-nav > div:first-child {{ background:linear-gradient(90deg,var(--cs-navy),var(--cs-purple) 65%,var(--cs-magenta));
+  border-radius:14px; padding:6px; margin:14px 0 10px; border:none !important; }}
+#cs-nav > .tab-wrapper button[role="tab"], #cs-nav > div:first-child > button[role="tab"],
+#cs-nav > .tab-wrapper .tab-container > button {{ color:#e9e9ff !important; font-weight:700 !important; font-size:15px !important;
+  border:none !important; border-radius:10px !important; padding:10px 18px !important; background:transparent !important; }}
+#cs-nav > .tab-wrapper button[role="tab"].selected, #cs-nav > div:first-child > button[role="tab"].selected,
+#cs-nav > .tab-wrapper .tab-container > button.selected {{ background:#fff !important; color:var(--cs-navy) !important;
+  box-shadow:0 3px 10px rgba(0,0,0,.18); }}
+#cs-nav > .tab-wrapper button[role="tab"]:hover {{ background:rgba(255,255,255,.14) !important; }}
+#cs-nav > .tab-wrapper .tab-container::after, #cs-nav > .tab-wrapper .overflow-menu {{ display:none !important; }}
+#cs-nav > .tab-wrapper .tab-container {{ height:auto !important; flex-wrap:wrap; gap:4px; }}
+
+.sub-tabs button[role="tab"] {{ font-weight:600 !important; }}
+.sub-tabs button[role="tab"].selected {{ color:var(--cs-navy) !important; border-color:var(--cs-magenta) !important; }}
+
+.cs-intro {{ background:#fff; border:1px solid #eceef6; border-radius:14px; padding:12px 16px; color:#444;
+  font-size:14px; margin-bottom:8px; }}
+.cs-intro b {{ color:var(--cs-navy); }}
+.cs-flow {{ display:flex; gap:8px; flex-wrap:wrap; margin-top:8px; }}
+.cs-flow span {{ background:#f1f3fb; border-radius:99px; padding:4px 12px; font-size:12.5px; font-weight:600; color:var(--cs-navy); }}
+
+.cs-card {{ background:#fff !important; border-radius:18px !important; padding:18px !important;
+  box-shadow:0 6px 24px rgba(7,34,139,.06) !important; border:1px solid #eceef6 !important; }}
+button.primary {{ background:linear-gradient(90deg,var(--cs-navy),var(--cs-purple) 60%,var(--cs-magenta)) !important;
+  color:#fff !important; border:none !important; font-weight:700 !important; font-size:16px !important;
+  border-radius:12px !important; box-shadow:0 6px 18px rgba(71,20,139,.28) !important; }}
+button.primary:hover {{ filter:brightness(1.08); }}
+
+.cs-lock {{ text-align:center; padding:34px 20px 18px; }}
+.cs-lock-ico {{ font-size:44px; }}
+.cs-lock-t {{ font-weight:800; font-size:20px; color:var(--cs-navy); margin-top:6px; }}
+.cs-lock-s {{ color:#666; font-size:14px; margin:6px auto 0; max-width:520px; }}
+.cs-lockbtn {{ max-width:260px !important; margin:0 auto 22px !important; }}
+
+.cs-scores {{ display:grid; grid-template-columns:repeat(4,1fr); gap:14px; margin-top:6px; }}
+@media (max-width:820px) {{ .cs-scores {{ grid-template-columns:repeat(2,1fr); }} }}
+.cs-scores.cs-empty {{ display:block; text-align:center; color:#888; padding:22px; border:2px dashed #e3e6f2; border-radius:16px; }}
+.cs-gauge {{ background:#fff; border:1px solid #eceef6; border-radius:16px; padding:16px 10px; text-align:center;
+  box-shadow:0 4px 16px rgba(7,34,139,.05); }}
+.cs-ring {{ width:104px; height:104px; margin:0 auto 10px; border-radius:50%;
+  background:conic-gradient(var(--c) calc(var(--p)*1%), #edf0f7 0); display:grid; place-items:center; }}
+.cs-ring-inner {{ width:80px; height:80px; border-radius:50%; background:#fff; display:grid; place-items:center; }}
+.cs-ring-inner span {{ font-size:22px; font-weight:800; color:#222; }}
+.cs-gauge-title {{ font-weight:700; color:var(--cs-navy); font-size:14px; }}
+.cs-chip {{ display:inline-block; margin:6px 0; padding:2px 12px; border-radius:99px; font-size:12px; font-weight:700; }}
+.cs-gauge-cap {{ font-size:11.5px; color:#777; line-height:1.35; }}
+.cs-disclaimer {{ margin-top:12px; font-size:12px; color:#666; background:#fff8ec; border-left:4px solid {BRAND['orange']};
+  padding:10px 14px; border-radius:10px; }}
+.cs-count {{ text-align:right; font-size:12px; margin-top:-6px; }}
+
+.cs-status {{ padding:16px 18px; border-radius:14px; font-size:14.5px; line-height:1.5; }}
+.cs-idle {{ color:#666; }}
+.cs-done {{ background:#f1fbf1; border-left:4px solid {BRAND['green']}; color:#234; }}
+.cs-err {{ background:#fff3f3; border-left:4px solid {BRAND['red']}; color:#8a1c1c; }}
+.cs-run {{ text-align:center; background:#fff; border:1px solid #eceef6; }}
+.cs-spin-logo {{ width:64px; height:64px; margin:4px auto 12px;
+  background:url("{FAVICON_SRC}") center/contain no-repeat; animation:cs-spin 1.4s linear infinite; }}
+.cs-st-text {{ font-weight:600; color:var(--cs-navy); margin-bottom:10px; }}
+.cs-bar {{ height:10px; border-radius:99px; background:#edf0f7; overflow:hidden; }}
+.cs-bar > div {{ height:100%; border-radius:99px; background:var(--cs-rainbow); transition:width .5s ease; }}
+.cs-st-meta {{ margin-top:8px; font-size:12px; color:#777; }}
+@keyframes cs-spin {{ to {{ transform:rotate(360deg); }} }}
+.cs-dl {{ display:block; text-align:center; margin-top:10px; padding:12px 16px; border-radius:12px; font-weight:700;
+  color:#fff !important; text-decoration:none !important;
+  background:linear-gradient(90deg,var(--cs-navy),var(--cs-purple) 60%,var(--cs-magenta)); }}
+.cs-settings {{ background:#f8f9fd !important; border:1px solid #eceef6 !important; border-radius:14px !important;
+  padding:12px 14px !important; margin:10px 0 !important; }}
+.cs-settings-title {{ font-weight:700; color:var(--cs-navy); font-size:15px; margin:0 0 4px; }}
+
+.cs-stats {{ display:grid; grid-template-columns:repeat(5,1fr); gap:12px; }}
+@media (max-width:820px) {{ .cs-stats {{ grid-template-columns:repeat(2,1fr); }} }}
+.cs-stat {{ background:#fff; border:1px solid #eceef6; border-radius:14px; padding:14px; text-align:center; }}
+.cs-stat .n {{ font-size:26px; font-weight:800; color:var(--cs-navy); }}
+.cs-stat .l {{ font-size:12px; color:#777; margin-top:2px; }}
+.cs-auth {{ max-width:480px; margin:10px auto 0 !important; }}
+.cs-auth-title {{ text-align:center; font-weight:800; font-size:22px; color:var(--cs-navy); margin:4px 0 2px; }}
+.cs-auth-sub {{ text-align:center; color:#666; font-size:13.5px; margin-bottom:10px; }}
+.cs-authmsg {{ padding:10px 14px; border-radius:10px; font-size:13.5px; margin-top:6px; }}
+.cs-ok {{ background:#f1fbf1; color:#1e5b1e; border-left:4px solid {BRAND['green']}; }}
+.cs-bad {{ background:#fff3f3; color:#8a1c1c; border-left:4px solid {BRAND['red']}; }}
+.cs-prof {{ display:grid; gap:8px; margin-top:12px; }}
+.cs-prof div {{ display:flex; justify-content:space-between; border-bottom:1px solid #f0f1f7; padding:6px 2px; }}
+.cs-prof span {{ color:#777; }}
+
+.cs-footer {{ text-align:center; margin-top:18px; padding:16px; color:#666; font-size:13px; }}
+.cs-footer .bar {{ height:3px; width:220px; margin:0 auto 12px; border-radius:3px; background:var(--cs-rainbow); }}
+.cs-footer a {{ color:var(--cs-navy); font-weight:700; text-decoration:none; }}
+"""
+
+FORCE_LIGHT = """
+() => {
+  const url = new URL(window.location);
+  if (url.searchParams.get('__theme') !== 'light') {
+    url.searchParams.set('__theme', 'light'); window.location.href = url.href; return;
+  }
+  const hide = () => { const h = document.getElementById('huggingface-space-header');
+    if (h) h.style.setProperty('display', 'none', 'important'); };
+  hide(); new MutationObserver(hide).observe(document.documentElement, { childList: true, subtree: true });
+  const ICON = "__FAVICON__";
+  if (ICON) { document.querySelectorAll("link[rel*='icon']").forEach(l => l.remove());
+    const link = document.createElement('link'); link.rel = 'icon'; link.type = 'image/png'; link.href = ICON;
+    document.head.appendChild(link); }
+}
+""".replace("__FAVICON__", FAVICON_SRC)
+
+_logo = f'<img src="{LOGO_SRC}" alt="logo">' if LOGO_SRC else ""
+_title = html.escape(APP_NAME)
+_title = _title.rsplit(" ", 1)[0] + f" <span>{_title.rsplit(' ', 1)[-1]}</span>" if " " in _title else _title
+HEADER = f"""
+<div class="cs-header">{_logo}
+  <div><h1>{_title}</h1>
+  <p>Detect AI-written passages and humanize them — sentence by sentence, with your Word layout kept intact.</p></div>
+</div>"""
+
+FOOTER = f"""
+<div class="cs-footer"><div class="bar"></div>
+  © CS Software Solutions · Tri-Crest Press &nbsp;|&nbsp; <a href="{SITE_URL}" target="_blank">cssoftwaresolutions.in</a><br>
+  Rewritten output should be checked for accuracy and properly cited before submission.
+</div>"""
+
+theme = gr.themes.Soft(primary_hue="indigo", secondary_hue="pink", neutral_hue="slate",
+                       font=[gr.themes.GoogleFont("Poppins"), "ui-sans-serif", "sans-serif"], radius_size="lg")
+
+HID = dict(show_progress="hidden", api_name=False)
+
+
+def thresholds():
+    with gr.Accordion("Detector thresholds", open=False):
+        hi = gr.Slider(0.5, 0.99, 0.80, step=0.01, label="High (cyan) ≥")
+        mod = gr.Slider(0.3, 0.95, 0.50, step=0.01, label="Moderate (purple) ≥ — sentences above this are rewritten")
+    return hi, mod
+
+
+def lock_gate(what):
+    """Returns (lock column, open column). Caller builds the upload UI inside the open column."""
+    lock = gr.Column(visible=True, elem_classes="cs-card")
+    with lock:
+        gr.HTML(_locked(what))
+        btn = gr.Button("🔐 Sign in / Create free account", variant="primary", elem_classes="cs-lockbtn")
+    opened = gr.Column(visible=False)
+    LOCKS.append(lock)
+    OPENS.append(opened)
+    return lock, opened, btn
+
+
+GOTO_ACCOUNT = []
+
+with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CSS, js=FORCE_LIGHT) as demo:
+    user_state = gr.State(None)
+    gr.HTML(HEADER)
+    with gr.Row(elem_id="cs-strip", equal_height=True):
+        user_bar = gr.HTML(_userbar(None))
+        top_signin = gr.Button("🔐 Sign in", size="sm", elem_classes="cs-topbtn", scale=0)
+        top_logout = gr.Button("Log out", size="sm", elem_classes="cs-topbtn", visible=False, scale=0)
+
+    with gr.Tabs(elem_id="cs-nav", selected="smart") as nav:
+        # ============================ SMART HUMANIZE ============================
+        with gr.Tab("🚀 Smart Humanize", id="smart"):
+            gr.HTML('<div class="cs-intro"><b>Detector + Humanizer together.</b> The AI detector scores every sentence, '
+                    'only the flagged ones are rewritten, then the text is re-checked — repeated until your target '
+                    'score or the pass limit is reached. Low-scoring sentences stay exactly as you wrote them.'
+                    '<div class="cs-flow"><span>1 · Detect</span><span>2 · Rewrite flagged sentences</span>'
+                    '<span>3 · Re-check</span><span>4 · Repeat</span></div></div>')
+            with gr.Group(elem_classes="cs-settings"):
+                gr.HTML('<div class="cs-settings-title">⚙️ Settings</div>')
+                with gr.Row():
+                    s_target = gr.Slider(0, 60, value=10, step=1, label="Target AI score (%)",
+                                         info="Stop as soon as the document is at or below this")
+                    s_passes = gr.Slider(1, 4, value=3, step=1, label="Maximum passes",
+                                         info="Each pass re-checks and rewrites what is still flagged")
+                with gr.Row():
+                    s_temp = gr.Slider(0.3, 1.5, value=0.9, step=0.1, label="Rewrite variation",
+                                       info="Increases a little on each extra pass")
+                    s_mode = gr.Radio(MODES, value=MODES[0], label="Processing")
+                s_hi, s_mod = thresholds()
+            with gr.Tabs(elem_classes="sub-tabs"):
+                with gr.Tab("✍️ Paste text (no sign-in)"):
+                    with gr.Row(equal_height=True):
+                        with gr.Column(elem_classes="cs-card"):
+                            sp_in = gr.Textbox(label="Your text", lines=14, max_lines=30,
+                                               placeholder="Paste paragraphs here, separated by a blank line (25+ words each).")
+                            sp_count = gr.HTML(H.count_words(""))
+                        with gr.Column(elem_classes="cs-card"):
+                            sp_out = gr.Textbox(label="Humanized text", lines=14, max_lines=30,
+                                                show_copy_button=True, interactive=False)
+                    sp_btn = gr.Button("🚀 Detect & humanize", variant="primary", size="lg")
+                    sp_status = gr.HTML(H.status_idle("Paste text and press **Detect & humanize**."))
+                    sp_scores = gr.HTML(EMPTY)
+                    with gr.Row():
+                        sp_file = gr.File(label="Download as .docx", interactive=False)
+                        sp_dl = gr.HTML()
+                    with gr.Accordion("Final AI highlight view", open=False):
+                        sp_prev = gr.HTML()
+                with gr.Tab("📄 Upload Word (.docx) 🔒"):
+                    _, sd_open, sd_lockbtn = lock_gate("Word documents")
+                    GOTO_ACCOUNT.append(sd_lockbtn)
+                    with sd_open:
+                        with gr.Row(equal_height=False):
+                            with gr.Column(elem_classes="cs-card"):
+                                sd_in = gr.File(label="Word document (.docx)", file_types=[".docx"], type="filepath")
+                                sd_btn = gr.Button("🚀 Detect & humanize document", variant="primary", size="lg")
+                                gr.Markdown("<small>Only flagged sentences are replaced; formatting of everything else, "
+                                            "tables, figures, equations and headers stay untouched. Citation fields, hyperlinks "
+                                            "and super/subscripts inside a sentence are never altered.</small>")
+                            with gr.Column(elem_classes="cs-card"):
+                                sd_status = gr.HTML(H.status_idle("Upload a .docx and press **Detect & humanize document**."))
+                                sd_file = gr.File(label="Download humanized .docx", interactive=False)
+                                sd_dl = gr.HTML()
+                        sd_scores = gr.HTML(EMPTY)
+                        with gr.Accordion("Final AI highlight view", open=False):
+                            sd_prev = gr.HTML()
+
+        # ============================ DETECTOR ============================
+        with gr.Tab("🔍 AI Detector", id="detect"):
+            gr.HTML('<div class="cs-intro"><b>AI Writing Report.</b> Sentence-level highlighting '
+                    '(cyan = high, purple = moderate) plus a downloadable PDF report. Results are probabilistic indicators.</div>')
+            d_hi, d_mod = thresholds()
+            with gr.Tabs(elem_classes="sub-tabs"):
+                with gr.Tab("✍️ Paste text (no sign-in)"):
+                    with gr.Row(equal_height=False):
+                        with gr.Column(scale=1, elem_classes="cs-card"):
+                            dp_in = gr.Textbox(label="Your text", lines=14, max_lines=30,
+                                               placeholder="Paste paragraphs here, separated by a blank line.")
+                            dp_btn = gr.Button("🔍 Check for AI", variant="primary", size="lg")
+                            dp_status = gr.HTML(H.status_idle("Paste text and press **Check for AI**."))
+                            dp_pdf = gr.File(label="PDF report", interactive=False)
+                            dp_to_smart = gr.Button("🚀 Humanize this text →")
+                        with gr.Column(scale=2):
+                            dp_html = gr.HTML()
+                with gr.Tab("📄 Upload document 🔒"):
+                    _, dd_open, dd_lockbtn = lock_gate("documents for AI detection")
+                    GOTO_ACCOUNT.append(dd_lockbtn)
+                    with dd_open:
+                        with gr.Row(equal_height=False):
+                            with gr.Column(scale=1, elem_classes="cs-card"):
+                                dd_in = gr.File(label="Document (.docx, .pdf, .txt)",
+                                                file_types=[".docx", ".pdf", ".txt", ".md"], type="filepath")
+                                dd_btn = gr.Button("🔍 Generate report", variant="primary", size="lg")
+                                dd_status = gr.HTML(H.status_idle("Upload a file and press **Generate report**."))
+                                dd_pdf = gr.File(label="PDF report", interactive=False)
+                                dd_to_smart = gr.Button("🚀 Humanize this .docx →")
+                            with gr.Column(scale=2):
+                                dd_html = gr.HTML()
+
+        # ============================ HUMANIZER ============================
+        with gr.Tab("✨ Humanizer", id="humanize"):
+            gr.HTML('<div class="cs-intro"><b>Full paraphrase.</b> Rewrites every eligible paragraph with the Parrot '
+                    'engine, then shows the detector score before and after. For targeted rewriting of only the '
+                    'AI-flagged sentences, use <b>Smart Humanize</b>.</div>')
+            with gr.Tabs(elem_classes="sub-tabs"):
+                with gr.Tab("✍️ Paste text (no sign-in)"):
+                    with gr.Row(equal_height=True):
+                        with gr.Column(elem_classes="cs-card"):
+                            hp_in = gr.Textbox(label="Your text", lines=14, max_lines=30,
+                                               placeholder="Paste your paragraphs here. Separate paragraphs with a blank line.")
+                            hp_count = gr.HTML(H.count_words(""))
+                        with gr.Column(elem_classes="cs-card"):
+                            hp_out = gr.Textbox(label="Paraphrased text", lines=14, max_lines=30,
+                                                show_copy_button=True, interactive=False)
+                    with gr.Row():
+                        with gr.Column():
+                            with gr.Group(elem_classes="cs-settings"):
+                                gr.HTML('<div class="cs-settings-title">⚙️ Settings</div>')
+                                hp_temp = gr.Slider(0.3, 1.5, value=0.9, step=0.1, label="Paraphrase variation")
+                                hp_min = gr.Slider(3, 30, value=6, step=1, label="Minimum words per paragraph")
+                                hp_mode = gr.Radio(MODES, value=MODES[0], label="Processing")
+                            hp_btn = gr.Button("✨ Paraphrase text", variant="primary", size="lg")
+                        with gr.Column():
+                            hp_status = gr.HTML(H.status_idle("Paste text and press **Paraphrase text**."))
+                            hp_file = gr.File(label="Download as .docx", interactive=False)
+                            hp_dl = gr.HTML()
+                            hp_to_det = gr.Button("🔍 Send result to AI Detector →")
+                    hp_scores = gr.HTML(EMPTY)
+                with gr.Tab("📄 Upload Word (.docx) 🔒"):
+                    _, hd_open, hd_lockbtn = lock_gate("Word documents")
+                    GOTO_ACCOUNT.append(hd_lockbtn)
+                    with hd_open:
+                        with gr.Row(equal_height=False):
+                            with gr.Column(elem_classes="cs-card"):
+                                hd_in = gr.File(label="Word document (.docx)", file_types=[".docx"], type="filepath")
+                                with gr.Group(elem_classes="cs-settings"):
+                                    gr.HTML('<div class="cs-settings-title">⚙️ Settings</div>')
+                                    hd_temp = gr.Slider(0.3, 1.5, value=0.9, step=0.1, label="Paraphrase variation")
+                                    hd_min = gr.Slider(5, 30, value=8, step=1, label="Minimum words per paragraph")
+                                    hd_mode = gr.Radio(MODES, value=MODES[0], label="Processing")
+                                hd_btn = gr.Button("✨ Paraphrase document", variant="primary", size="lg")
+                            with gr.Column(elem_classes="cs-card"):
+                                hd_status = gr.HTML(H.status_idle("Upload a document and press **Paraphrase document**."))
+                                hd_file = gr.File(label="Download paraphrased .docx", interactive=False)
+                                hd_dl = gr.HTML()
+                        hd_scores = gr.HTML(EMPTY)
+                        with gr.Accordion("Preview of changes (first 10)", open=False):
+                            hd_prev = gr.Markdown()
+
+        # ============================ ACCOUNT ============================
+        with gr.Tab("👤 Account", id="account"):
+            with gr.Column(visible=True, elem_classes="cs-auth") as auth_view:
+                with gr.Column(elem_classes="cs-card"):
+                    gr.HTML('<div class="cs-auth-title">Welcome</div>'
+                            '<div class="cs-auth-sub">Sign in or create a free account to upload documents. '
+                            'Pasting text never needs an account.</div>')
+                    with gr.Tabs():
+                        with gr.Tab("🔐 Log in"):
+                            li_email = gr.Textbox(label="Email", placeholder="you@university.edu")
+                            li_pw = gr.Textbox(label="Password", type="password")
+                            li_btn = gr.Button("Log in", variant="primary", size="lg")
+                        with gr.Tab("📝 Sign up"):
+                            su_name = gr.Textbox(label="Full name")
+                            su_email = gr.Textbox(label="Email", placeholder="you@university.edu")
+                            su_pw = gr.Textbox(label="Password", type="password", info="At least 8 characters")
+                            su_pw2 = gr.Textbox(label="Confirm password", type="password")
+                            su_btn = gr.Button("Create account", variant="primary", size="lg")
+            with gr.Column(visible=False, elem_classes="cs-auth") as profile_view:
+                with gr.Column(elem_classes="cs-card"):
+                    profile_html = gr.HTML()
+                    prof_logout = gr.Button("Log out")
+            auth_msg = gr.HTML()
+
+        # ============================ ADMIN ============================
+        with gr.Tab("🛡️ Admin", id="admin", visible=False) as admin_tab:
+            ad_stats = gr.HTML()
+            with gr.Row():
+                ad_query = gr.Textbox(label="Search users", placeholder="Name or email", scale=4)
+                ad_refresh = gr.Button("🔄 Refresh", scale=1)
+                ad_export = gr.Button("⬇️ Export CSV", scale=1)
+            ad_table = gr.Dataframe(headers=A.ADMIN_COLS, interactive=False, wrap=True)
+            ad_csv = gr.File(label="Users export", interactive=False)
+            with gr.Row(equal_height=False):
+                with gr.Column(elem_classes="cs-card"):
+                    gr.HTML('<div class="cs-settings-title">Enable / disable account</div>')
+                    ad_email = gr.Textbox(label="User email")
+                    with gr.Row():
+                        ad_disable = gr.Button("🚫 Disable")
+                        ad_enable = gr.Button("✅ Enable")
+                with gr.Column(elem_classes="cs-card"):
+                    gr.HTML('<div class="cs-settings-title">Reset password</div>')
+                    ad_pw_email = gr.Textbox(label="User email")
+                    ad_new_pw = gr.Textbox(label="New password", type="password")
+                    ad_reset = gr.Button("🔑 Reset password")
+                with gr.Column(elem_classes="cs-card"):
+                    gr.HTML('<div class="cs-settings-title">Delete account</div>')
+                    ad_del_email = gr.Textbox(label="User email")
+                    ad_del_confirm = gr.Textbox(label="Type the email again to confirm")
+                    ad_delete = gr.Button("🗑️ Delete user", variant="stop")
+            ad_msg = gr.HTML()
+
+    gr.HTML(FOOTER)
+
+    # ============================ EVENTS ============================
+    # navigation shortcuts
+    for b in GOTO_ACCOUNT + [top_signin]:
+        b.click(lambda: gr.Tabs(selected="account"), None, nav, **HID)
+    dp_to_smart.click(lambda t: (gr.Tabs(selected="smart"), t), dp_in, [nav, sp_in], **HID)
+    dd_to_smart.click(lambda f: (gr.Tabs(selected="smart"), f if f and str(f).lower().endswith(".docx") else None),
+                      dd_in, [nav, sd_in], **HID)
+    hp_to_det.click(lambda t: (gr.Tabs(selected="detect"), t), hp_out, [nav, dp_in], **HID)
+
+    # auth
+    auth_out = ([user_state, auth_view, profile_view, profile_html, user_bar, auth_msg, admin_tab,
+                 ad_stats, ad_table, top_signin, top_logout] + LOCKS + OPENS)
+    li_btn.click(do_login, [li_email, li_pw], auth_out, **HID)
+    li_pw.submit(do_login, [li_email, li_pw], auth_out, **HID)
+    su_btn.click(do_signup, [su_name, su_email, su_pw, su_pw2], auth_out, **HID)
+    su_pw2.submit(do_signup, [su_name, su_email, su_pw, su_pw2], auth_out, **HID)
+    for b in (top_logout, prof_logout):
+        b.click(do_logout, None, auth_out, **HID)
+
+    # admin
+    ad_out = [ad_stats, ad_table, ad_msg]
+    ad_refresh.click(lambda u, q: A._admin_refresh(u, q, "Refreshed."), [user_state, ad_query], ad_out, **HID)
+    ad_query.submit(A.admin_search, [user_state, ad_query], ad_table, **HID)
+    ad_disable.click(lambda u, e, q: A.admin_set_active(u, e, q, False), [user_state, ad_email, ad_query], ad_out, **HID)
+    ad_enable.click(lambda u, e, q: A.admin_set_active(u, e, q, True), [user_state, ad_email, ad_query], ad_out, **HID)
+    ad_reset.click(A.admin_reset_pw, [user_state, ad_pw_email, ad_new_pw, ad_query], ad_out, **HID)
+    ad_delete.click(A.admin_delete, [user_state, ad_del_email, ad_del_confirm, ad_query], ad_out, **HID)
+    ad_export.click(A.admin_export, [user_state], ad_csv, **HID)
+
+    # smart humanize
+    sp_in.change(H.count_words, sp_in, sp_count, queue=False, **HID)
+    sp_btn.click(smart_text, [sp_in, s_target, s_passes, s_temp, s_mode, s_hi, s_mod, user_state],
+                 [sp_status, sp_out, sp_prev, sp_scores, sp_file, sp_dl], **HID)
+    sd_btn.click(smart_docx, [sd_in, s_target, s_passes, s_temp, s_mode, s_hi, s_mod, user_state],
+                 [sd_status, sd_prev, sd_scores, sd_file, sd_dl], **HID)
+
+    # detector
+    dp_btn.click(detect_text, [dp_in, d_hi, d_mod, user_state], [dp_status, dp_html, dp_pdf], **HID)
+    dd_btn.click(detect_file, [dd_in, d_hi, d_mod, user_state], [dd_status, dd_html, dd_pdf], **HID)
+
+    # humanizer
+    hp_in.change(H.count_words, hp_in, hp_count, queue=False, **HID)
+    hp_btn.click(humanize_text, [hp_in, hp_temp, hp_min, hp_mode, user_state],
+                 [hp_out, hp_file, hp_dl, hp_status, hp_scores], **HID)
+    hd_btn.click(humanize_docx, [hd_in, hd_temp, hd_min, hd_mode, user_state],
+                 [hd_file, hd_dl, hd_status, hd_scores, hd_prev], **HID)
+
+demo.queue(default_concurrency_limit=2, max_size=30)
+
+if __name__ == "__main__":
+    demo.launch(show_api=False, ssr_mode=False, allowed_paths=[str(OUT_DIR)],
+                favicon_path=str(FAVICON_PATH) if FAVICON_PATH.exists() else None)

auth.py

@@ -0,0 +1,191 @@
+"""Accounts (email + password, PBKDF2, SQLite) and admin helpers."""
+import hashlib, hmac, os, re, secrets, sqlite3, tempfile
+from pathlib import Path
+
+import gradio as gr
+
+OUT_DIR = Path(tempfile.gettempdir()) / "cs_outputs"
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# ---------------------------------------------------------------------------
+# Accounts (email + password, PBKDF2-hashed, SQLite)
+# Stored in /data when persistent storage is enabled; otherwise next to app.py.
+# ---------------------------------------------------------------------------
+_DATA_DIR = Path("/data") if Path("/data").is_dir() and os.access("/data", os.W_OK) else Path(__file__).parent
+USERS_DB = Path(os.getenv("USERS_DB", str(_DATA_DIR / "users.db")))
+_EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+
+
+def _db():
+    con = sqlite3.connect(str(USERS_DB), timeout=10)
+    con.execute(
+        "CREATE TABLE IF NOT EXISTS users (email TEXT PRIMARY KEY, name TEXT, salt TEXT, "
+        "pw TEXT, created TEXT DEFAULT CURRENT_TIMESTAMP, last_login TEXT, runs INTEGER DEFAULT 0)"
+    )
+    cols = {r[1] for r in con.execute("PRAGMA table_info(users)")}
+    if "active" not in cols:
+        con.execute("ALTER TABLE users ADD COLUMN active INTEGER DEFAULT 1")
+    return con
+
+
+# Admins: comma-separated emails in the ADMIN_EMAILS secret (Space settings → Variables and secrets).
+ADMIN_EMAILS = {e.strip().lower() for e in os.getenv("ADMIN_EMAILS", "").split(",") if e.strip()}
+
+
+def is_admin(user):
+    return bool(user and user.get("email", "").lower() in ADMIN_EMAILS)
+
+
+def _hash(password, salt):
+    return hashlib.pbkdf2_hmac("sha256", password.encode(), bytes.fromhex(salt), 200_000).hex()
+
+
+def create_user(name, email, password, confirm):
+    name, email = (name or "").strip(), (email or "").strip().lower()
+    if not name:
+        return None, "Please enter your name."
+    if not _EMAIL_RE.match(email):
+        return None, "Please enter a valid email address."
+    if len(password or "") < 8:
+        return None, "Password must be at least 8 characters."
+    if password != confirm:
+        return None, "Passwords do not match."
+    salt = secrets.token_hex(16)
+    with _db() as con:
+        if con.execute("SELECT 1 FROM users WHERE email=?", (email,)).fetchone():
+            return None, "An account with this email already exists. Please log in."
+        con.execute("INSERT INTO users (email, name, salt, pw, last_login) VALUES (?,?,?,?,CURRENT_TIMESTAMP)",
+                    (email, name, salt, _hash(password, salt)))
+    return {"email": email, "name": name}, None
+
+
+def check_user(email, password):
+    email = (email or "").strip().lower()
+    with _db() as con:
+        row = con.execute("SELECT name, salt, pw, active FROM users WHERE email=?", (email,)).fetchone()
+        if not row or not hmac.compare_digest(row[2], _hash(password or "", row[1])):
+            return None, "Incorrect email or password."
+        if row[3] == 0:
+            return None, "This account has been disabled. Please contact CS Software Solutions."
+        con.execute("UPDATE users SET last_login=CURRENT_TIMESTAMP WHERE email=?", (email,))
+    return {"email": email, "name": row[0]}, None
+
+
+def _count_run(user):
+    try:
+        with _db() as con:
+            con.execute("UPDATE users SET runs = runs + 1 WHERE email=?", (user["email"],))
+    except Exception:
+        pass
+
+
+def _require(user):
+    if not user or not user.get("email"):
+        raise gr.Error("Please sign in to upload documents. Pasting text works without an account.")
+    with _db() as con:
+        row = con.execute("SELECT active FROM users WHERE email=?", (user["email"],)).fetchone()
+    if not row or row[0] == 0:
+        raise gr.Error("This account has been disabled.")
+
+
+def _msg(text, ok=False):
+    cls = "cs-ok" if ok else "cs-bad"
+    return f'<div class="cs-authmsg {cls}">{text}</div>' if text else ""
+
+
+# ---------------------------------------------------------------------------
+# Admin panel
+# ---------------------------------------------------------------------------
+ADMIN_COLS = ["Name", "Email", "Joined", "Last login", "Runs", "Status", "Role"]
+
+
+def _need_admin(user):
+    if not is_admin(user):
+        raise gr.Error("Admin access only.")
+
+
+def admin_stats(user):
+    _need_admin(user)
+    with _db() as con:
+        total = con.execute("SELECT COUNT(*) FROM users").fetchone()[0]
+        active = con.execute("SELECT COUNT(*) FROM users WHERE active=1").fetchone()[0]
+        runs = con.execute("SELECT COALESCE(SUM(runs),0) FROM users").fetchone()[0]
+        new7 = con.execute("SELECT COUNT(*) FROM users WHERE created >= datetime('now','-7 days')").fetchone()[0]
+        seen7 = con.execute("SELECT COUNT(*) FROM users WHERE last_login >= datetime('now','-7 days')").fetchone()[0]
+    tiles = [("Total users", total), ("Active accounts", active), ("Total runs", runs),
+             ("New (7 days)", new7), ("Logged in (7 days)", seen7)]
+    cells = "".join(f'<div class="cs-stat"><div class="n">{v:,}</div><div class="l">{k}</div></div>' for k, v in tiles)
+    return f'<div class="cs-stats">{cells}</div>'
+
+
+def admin_table(user, query=""):
+    _need_admin(user)
+    q = f"%{(query or '').strip().lower()}%"
+    with _db() as con:
+        rows = con.execute(
+            "SELECT name, email, created, last_login, runs, active FROM users "
+            "WHERE lower(name) LIKE ? OR lower(email) LIKE ? ORDER BY created DESC", (q, q)).fetchall()
+    return [[n, e, (c or "")[:16], (l or "")[:16], r, "Active" if a else "Disabled",
+             "Admin" if e in ADMIN_EMAILS else "User"] for n, e, c, l, r, a in rows]
+
+
+def _admin_refresh(user, query, note, ok=True):
+    return admin_stats(user), admin_table(user, query), _msg(note, ok=ok)
+
+
+def admin_search(user, query):
+    _need_admin(user)
+    return admin_table(user, query)
+
+
+def admin_set_active(user, email, query, active):
+    _need_admin(user)
+    email = (email or "").strip().lower()
+    if not email:
+        return _admin_refresh(user, query, "Enter the user's email first.", ok=False)
+    if email in ADMIN_EMAILS and not active:
+        return _admin_refresh(user, query, "Admin accounts can't be disabled here.", ok=False)
+    with _db() as con:
+        n = con.execute("UPDATE users SET active=? WHERE email=?", (1 if active else 0, email)).rowcount
+    if not n:
+        return _admin_refresh(user, query, f"No user found with {email}.", ok=False)
+    return _admin_refresh(user, query, f"{email} is now {'active' if active else 'disabled'}.")
+
+
+def admin_reset_pw(user, email, new_pw, query):
+    _need_admin(user)
+    email = (email or "").strip().lower()
+    if len(new_pw or "") < 8:
+        return _admin_refresh(user, query, "New password must be at least 8 characters.", ok=False)
+    salt = secrets.token_hex(16)
+    with _db() as con:
+        n = con.execute("UPDATE users SET salt=?, pw=? WHERE email=?", (salt, _hash(new_pw, salt), email)).rowcount
+    if not n:
+        return _admin_refresh(user, query, f"No user found with {email}.", ok=False)
+    return _admin_refresh(user, query, f"Password reset for {email}. Share it with them securely.")
+
+
+def admin_delete(user, email, confirm, query):
+    _need_admin(user)
+    email = (email or "").strip().lower()
+    if (confirm or "").strip().lower() != email or not email:
+        return _admin_refresh(user, query, "Type the same email in the confirm box to delete.", ok=False)
+    if email in ADMIN_EMAILS:
+        return _admin_refresh(user, query, "Admin accounts can't be deleted here.", ok=False)
+    with _db() as con:
+        n = con.execute("DELETE FROM users WHERE email=?", (email,)).rowcount
+    if not n:
+        return _admin_refresh(user, query, f"No user found with {email}.", ok=False)
+    return _admin_refresh(user, query, f"Deleted {email}.")
+
+
+def admin_export(user):
+    _need_admin(user)
+    import csv
+    folder = Path(tempfile.mkdtemp(dir=OUT_DIR))
+    path = folder / "users.csv"
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow(ADMIN_COLS)
+        w.writerows(admin_table(user))
+    return str(path)

detector.py

@@ -0,0 +1,689 @@
+"""
+AI Writing Report — Hugging Face Space
+Detector: coai/roberta-ai-detector-v2 (gated model -> add an HF_TOKEN secret whose account accepted the terms)
+Input: .docx / .pdf / .txt or pasted text  ->  highlighted PDF report + on-screen preview
+PDF and DOCX inputs keep their original layout: highlights are drawn onto the source pages
+(DOCX is converted to PDF with LibreOffice first), so figures, equations and tables are untouched.
+"""
+import os, re, html, datetime, tempfile, shutil, subprocess
+from dataclasses import dataclass, field
+
+import gradio as gr
+import docx_report as DX
+
+# ---------------------------------------------------------------- config
+MODEL_ID = os.getenv("DETECTOR_MODEL", "coai/roberta-ai-detector-v2")
+HF_TOKEN = os.getenv("HF_TOKEN")
+BRAND = os.getenv("REPORT_BRAND", "CS SOFTWARE SOLUTIONS")
+MIN_PARA_WORDS = 25        # shorter blocks (headings, captions) are not analysed
+WINDOW_WORDS = 90          # detector context per window (model is weak below ~50 words)
+MAX_WINDOW_WORDS = 320     # keeps each window under 512 tokens
+BATCH = 16
+HIGH_COLOR = "#A9E4EE"     # cyan
+MOD_COLOR = "#E4DCF5"      # light purple
+
+try:  # ZeroGPU (HF Pro). Falls back to plain CPU/GPU hardware.
+    import spaces
+    ZERO = True
+except Exception:
+    spaces, ZERO = None, False
+
+def _duration(texts):
+    # ~0.05 s per window on ZeroGPU + load overhead; capped for long theses
+    return min(300, 30 + int(len(texts) * 0.05))
+
+def gpu(fn):
+    return spaces.GPU(duration=_duration)(fn) if ZERO else fn
+
+# ---------------------------------------------------------------- model
+# Loaded once at startup. On ZeroGPU the model must be created (and moved to
+# "cuda") at module level, not inside the @spaces.GPU function, or it is
+# re-downloaded / re-loaded on every request.
+_tok, _model = None, None
+
+def load_model():
+    global _tok, _model
+    if _model is None:
+        import torch
+        from transformers import AutoTokenizer, AutoModelForSequenceClassification
+        _tok = AutoTokenizer.from_pretrained(MODEL_ID, token=HF_TOKEN)
+        _model = AutoModelForSequenceClassification.from_pretrained(MODEL_ID, token=HF_TOKEN).eval()
+        if ZERO or torch.cuda.is_available():
+            _model.to("cuda")
+    return _tok, _model
+
+if os.getenv("SKIP_MODEL_LOAD") != "1":
+    load_model()
+    DX.start_lo_init()            # fetch newest LibreOffice in the background
+
+@gpu
+def score_texts(texts):
+    """P(AI) for each text. Label index 1 = AI-generated (per model card)."""
+    import torch
+    tok, model = load_model()
+    dev = next(model.parameters()).device
+    bs = 32 if dev.type == "cuda" else BATCH
+    out = []
+    for i in range(0, len(texts), bs):
+        enc = tok(texts[i:i + bs], return_tensors="pt", truncation=True,
+                  max_length=512, padding=True).to(dev)
+        with torch.no_grad():
+            p = torch.softmax(model(**enc).logits.float(), dim=-1)[:, 1]
+        out.extend(p.cpu().tolist())
+    return out
+
+# ---------------------------------------------------------------- extraction
+@dataclass
+class Block:
+    text: str
+    kind: str = "para"            # para | heading | table | skip
+    sents: list = field(default_factory=list)
+    rows: list = field(default_factory=list)   # table cells (list of rows)
+    scores: list = field(default_factory=list)
+    words: list = field(default_factory=list)  # raw words (layout path)
+    toks: list = field(default_factory=list)   # (page, block, line, bbox) per word
+    spans: list = field(default_factory=list)  # (start, end) word index per sentence
+    el: object = None                           # w:p element (docx path)
+    raw: str = ""                               # exact paragraph text (docx path)
+    cspans: list = field(default_factory=list)  # (start, end) char range per sentence
+
+REF_HEAD = re.compile(r"^\s*(\d+\.?\s*)?(references|bibliography|works cited|literature cited)\s*$", re.I)
+BULLET = re.compile(r"^\s*([•●▪\-\*–]|\(?[a-z0-9]{1,2}[\)\.])\s+")
+
+def _norm(t):
+    return re.sub(r"[ \t ]+", " ", t.replace("\r", "")).strip()
+
+def extract_docx(path):
+    import docx
+    from docx.text.paragraph import Paragraph
+    from docx.table import Table
+    d = docx.Document(path)
+    blocks = []
+    for child in d.element.body.iterchildren():
+        tag = child.tag.split("}")[-1]
+        if tag == "p":
+            p = Paragraph(child, d)
+            t = _norm(p.text)
+            if not t:
+                continue
+            style = (p.style.name or "").lower() if p.style is not None else ""
+            kind = "heading" if ("heading" in style or "title" in style) else "para"
+            if "list" in style and len(t.split()) < MIN_PARA_WORDS:
+                kind = "skip"
+            blocks.append(Block(t, kind))
+        elif tag == "tbl":
+            tbl = Table(child, d)
+            rows = []
+            for r in tbl.rows:
+                cells, prev = [], None
+                for c in r.cells:              # merged cells repeat the same _tc
+                    if prev is not None and c._tc is prev:
+                        continue
+                    prev = c._tc
+                    cells.append(_norm(c.text))
+                rows.append(cells)
+            rows = [r for r in rows if any(r)]
+            if rows:
+                blocks.append(Block("\n".join(" | ".join(r) for r in rows), "table", rows=rows))
+    return blocks
+
+def extract_pdf(path):
+    import pymupdf as fitz
+    blocks = []
+    with fitz.open(path) as doc:
+        for page in doc:
+            h = page.rect.height
+            items = []                                   # (y, Block)
+            tboxes = []
+            try:
+                for tb in page.find_tables().tables:
+                    rows = [[_norm(c or "") for c in r] for r in tb.extract()]
+                    rows = [r for r in rows if any(r)]
+                    if len(rows) >= 2 and max(len(r) for r in rows) >= 2:
+                        tboxes.append(fitz.Rect(tb.bbox))
+                        items.append((tb.bbox[1], Block("\n".join(" | ".join(r) for r in rows),
+                                                        "table", rows=rows)))
+            except Exception:
+                pass
+            for b in page.get_text("blocks", sort=True):
+                x0, y0, x1, y1, t, _, btype = b
+                if btype != 0:
+                    continue
+                if y1 < h * 0.06 or y0 > h * 0.94:     # running header / footer
+                    continue
+                r = fitz.Rect(x0, y0, x1, y1)
+                if any(tr.intersects(r) and (tr & r).get_area() > 0.5 * r.get_area() for tr in tboxes):
+                    continue                             # text already captured in a table
+                t = _norm(re.sub(r"-\n(?=[a-z])", "", t).replace("\n", " "))
+                if t:
+                    items.append((y0, Block(t)))
+            blocks.extend(b for _, b in sorted(items, key=lambda x: x[0]))
+    # re-join paragraphs split across page / column breaks
+    merged = []
+    for b in blocks:
+        if merged and merged[-1].kind == "para" and not re.search(r"[.!?:\"”)]$", merged[-1].text) \
+                and b.text[:1].islower():
+            merged[-1].text += " " + b.text
+        else:
+            merged.append(b)
+    return merged
+
+def _dehyphen(t):
+    return re.sub(r"(\w)- ([a-z])", r"\1\2", t)
+
+def extract_pdf_layout(path):
+    """Paragraph blocks that remember where every word sits on the page."""
+    import pymupdf as fitz
+    blocks = []
+    with fitz.open(path) as doc:
+        for pno, page in enumerate(doc):
+            h = page.rect.height
+            tables, tboxes = [], []
+            try:
+                for tb in page.find_tables().tables:
+                    rows = [[_norm(c or "") for c in r] for r in tb.extract()]
+                    rows = [r for r in rows if any(r)]
+                    if len(rows) >= 2 and max(len(r) for r in rows) >= 2:
+                        tboxes.append(fitz.Rect(tb.bbox))
+                        tables.append((tb.bbox[1], Block("\n".join(" | ".join(r) for r in rows),
+                                                         "table", rows=rows)))
+            except Exception:
+                pass
+            bywords = {}
+            for w in page.get_text("words"):
+                bywords.setdefault(w[5], []).append(w)
+            page_blocks = []
+            for b in page.get_text("blocks", sort=True):
+                x0, y0, x1, y1, _, bno, btype = b
+                if btype != 0 or bno not in bywords:
+                    continue
+                if y1 < h * 0.06 or y0 > h * 0.94:        # running header / footer
+                    continue
+                r = fitz.Rect(x0, y0, x1, y1)
+                if any(tr.intersects(r) and (tr & r).get_area() > 0.5 * r.get_area() for tr in tboxes):
+                    continue                                # part of a table
+                ws = sorted(bywords[bno], key=lambda w: (w[6], w[7]))
+                words = [w[4] for w in ws]
+                toks = [(pno, bno, w[6], (w[0], w[1], w[2], w[3])) for w in ws]
+                page_blocks.append((y0, Block(" ".join(words), words=words, toks=toks)))
+            # place detected tables at their vertical position
+            for ty, tblk in sorted(tables, key=lambda x: x[0]):
+                idx = next((i for i, (y, _) in enumerate(page_blocks) if y > ty), len(page_blocks))
+                page_blocks.insert(idx, (ty, tblk))
+            blocks.extend(b for _, b in page_blocks)
+    # re-join paragraphs split across page / column breaks
+    merged = []
+    for b in blocks:
+        if merged and b.kind == "para" and merged[-1].kind == "para" and merged[-1].toks \
+                and not re.search(r"[.!?:\"”)]$", merged[-1].text) and b.text[:1].islower():
+            m = merged[-1]
+            m.text += " " + b.text
+            m.words += b.words
+            m.toks += b.toks
+        else:
+            merged.append(b)
+    return merged
+
+def layout_sentences(b):
+    """Sentence spans over the block's word list (+ clean display text)."""
+    sents = split_sentences(" ".join(b.words))
+    counts = [len(s.split()) for s in sents]
+    if sum(counts) != len(b.words):
+        sents, counts = [" ".join(b.words)], [len(b.words)]
+    spans, i = [], 0
+    for c in counts:
+        spans.append((i, i + c))
+        i += c
+    b.spans = spans
+    b.sents = [_dehyphen(s) for s in sents]
+
+def extract_docx_live(doc):
+    """Blocks bound to the paragraphs of an open python-docx Document."""
+    blocks = []
+    for kind, obj in DX.iter_body(doc):
+        if kind == "p":
+            raw = DX.para_text(obj._p)
+            t = re.sub(r"\s+", " ", raw).strip()
+            if not t:
+                continue
+            style = (obj.style.name or "").lower() if obj.style is not None else ""
+            k = "heading" if ("heading" in style or "title" in style) else "para"
+            if ("list" in style or "caption" in style) and len(t.split()) < MIN_PARA_WORDS:
+                k = "skip"
+            blocks.append(Block(t, k, el=obj._p, raw=raw))
+        else:
+            rows = []
+            for r in obj.rows:
+                cells, prev = [], None
+                for c in r.cells:
+                    if prev is not None and c._tc is prev:
+                        continue
+                    prev = c._tc
+                    cells.append(_norm(c.text))
+                rows.append(cells)
+            rows = [r for r in rows if any(r)]
+            if rows:
+                blocks.append(Block("\n".join(" | ".join(r) for r in rows), "table", rows=rows))
+    return blocks
+
+def extract_text(raw):
+    return [Block(_norm(p)) for p in re.split(r"\n\s*\n", raw.replace("\r", "")) if _norm(p)]
+
+def classify(blocks):
+    in_refs = False
+    for b in blocks:
+        if REF_HEAD.match(b.text):
+            b.kind, in_refs = "heading", True
+            continue
+        if in_refs:
+            b.kind = "skip"
+            continue
+        if b.kind in ("table", "skip", "heading"):
+            continue
+        wc = len(b.text.split())
+        wordy = sum(1 for w in b.text.split() if re.fullmatch(r"[A-Za-z][A-Za-z'’\-]+[.,;:)]?", w))
+        if wc and wordy / wc < 0.55:                       # equations, symbols, numeric lists
+            b.kind = "skip"
+            continue
+        if re.match(r"^(fig(ure)?|table)\s*\.?\s*\d", b.text, re.I) and wc < 40:
+            b.kind = "skip"
+        elif BULLET.match(b.text) and wc < MIN_PARA_WORDS:
+            b.kind = "skip"
+        elif wc < MIN_PARA_WORDS:
+            b.kind = "heading" if wc <= 14 and not b.text.endswith(".") else "skip"
+    return blocks
+
+# ---------------------------------------------------------------- sentences
+_ABBR = r"(?:et al|e\.g|i\.e|etc|vs|Fig|Figs|Eq|Eqs|Ref|Refs|No|Vol|pp|Dr|Mr|Mrs|Ms|Prof|approx|cf|Sec|Ch)"
+
+def split_sentences(t):
+    t = re.sub(rf"\b({_ABBR})\.", lambda m: m.group(1).replace(".", "<DOT>") + "<DOT>", t)
+    t = re.sub(r"(\d)\.(\d)", r"\1<DOT>\2", t)
+    parts = re.split(r"(?<=[.!?])[\"”’)]?\s+(?=[A-Z0-9\[\(“\"])", t)
+    return [p.replace("<DOT>", ".").strip() for p in parts if p.strip()]
+
+# ---------------------------------------------------------------- analysis
+def make_windows(lengths):
+    """Overlapping sentence windows of ~WINDOW_WORDS words (≈50% overlap)."""
+    windows, i, n = [], 0, len(lengths)
+    while i < n:
+        j, wc = i + 1, lengths[i]
+        while j < n and wc < WINDOW_WORDS and wc + lengths[j] <= MAX_WINDOW_WORDS:
+            wc += lengths[j]
+            j += 1
+        windows.append((i, j))
+        if j >= n:
+            break
+        i = max(i + 1, i + (j - i) // 2)
+    return windows
+
+def analyse(blocks, scorer=None):
+    scorer = scorer or score_texts
+    stream = []   # (block_idx, sent_idx, text, wordcount)
+    for bi, b in enumerate(blocks):
+        if b.kind != "para":
+            continue
+        if b.toks:
+            layout_sentences(b)
+        elif b.el is not None:
+            raws = split_sentences(b.raw)
+            b.cspans = DX.sentence_char_spans(b.raw, raws)
+            b.sents = [re.sub(r"\s+", " ", x).strip() for x in raws]
+        else:
+            b.sents = split_sentences(b.text)
+        b.scores = [0.0] * len(b.sents)
+        for si, s in enumerate(b.sents):
+            stream.append((bi, si, s, len(s.split())))
+    if not stream:
+        return blocks
+
+    windows = make_windows([x[3] for x in stream])
+    probs = scorer([" ".join(stream[k][2] for k in range(a, b)) for a, b in windows])
+
+    acc, cnt = [0.0] * len(stream), [0] * len(stream)
+    for (a, b), p in zip(windows, probs):
+        for k in range(a, b):
+            acc[k] += p
+            cnt[k] += 1
+    for k, (bi, si, _, _) in enumerate(stream):
+        blocks[bi].scores[si] = acc[k] / max(cnt[k], 1)
+
+    # light paragraph smoothing -> less speckled highlighting
+    for b in blocks:
+        if b.kind == "para" and b.scores:
+            m = sum(b.scores) / len(b.scores)
+            b.scores = [0.7 * s + 0.3 * m for s in b.scores]
+    return blocks
+
+def summarise(blocks, hi, mod):
+    total = hi_w = mod_w = 0
+    for b in blocks:
+        if b.kind != "para":
+            continue
+        for s, p in zip(b.sents, b.scores):
+            w = len(s.split())
+            total += w
+            if p >= hi:
+                hi_w += w
+            elif p >= mod:
+                mod_w += w
+    pct = round(100 * (hi_w + mod_w) / total) if total else 0
+    return dict(pct=pct, analysed=total, high=hi_w, moderate=mod_w,
+                all_words=sum(len(b.text.split()) for b in blocks))
+
+def band(pct):
+    if pct < 20:
+        return "Low likelihood of AI-generated content"
+    if pct <= 50:
+        return "Moderate likelihood of AI-generated content"
+    return "High likelihood of AI-generated content"
+
+# ---------------------------------------------------------------- PDF report
+def build_pdf(blocks, stats, fname, fsize_kb, hi, mod, out_path, summary_only=False):
+    from reportlab.lib.pagesizes import A4
+    from reportlab.lib.units import mm
+    from reportlab.lib import colors
+    from reportlab.lib.styles import ParagraphStyle
+    from reportlab.platypus import (BaseDocTemplate, Frame, PageTemplate, Paragraph,
+                                    Spacer, Table, TableStyle, PageBreak)
+    from reportlab.pdfgen import canvas as rl_canvas
+    from reportlab.pdfbase import pdfmetrics
+    from reportlab.pdfbase.ttfonts import TTFont
+
+    serif, serif_b, sans, sans_b = "Times-Roman", "Times-Bold", "Helvetica", "Helvetica-Bold"
+    fdir = "/usr/share/fonts/truetype/dejavu/"
+    try:
+        for a, f in [("Serif", "DejaVuSerif.ttf"), ("SerifB", "DejaVuSerif-Bold.ttf"),
+                     ("Sans", "DejaVuSans.ttf"), ("SansB", "DejaVuSans-Bold.ttf")]:
+            pdfmetrics.registerFont(TTFont(a, fdir + f))
+        serif, serif_b, sans, sans_b = "Serif", "SerifB", "Sans", "SansB"   # Unicode-safe
+    except Exception:
+        pass
+
+    now = datetime.datetime.now(datetime.timezone.utc).strftime("%B %d, %Y at %I:%M %p UTC")
+
+    class NumberedCanvas(rl_canvas.Canvas):
+        def __init__(self, *a, **k):
+            super().__init__(*a, **k)
+            self._saved = []
+        def showPage(self):
+            self._saved.append(dict(self.__dict__))
+            self._startPage()
+        def save(self):
+            total = len(self._saved)
+            for st in self._saved:
+                self.__dict__.update(st)
+                w, h = A4
+                self.setFont(sans, 8)
+                self.setFillColor(colors.HexColor("#555555"))
+                self.drawString(18 * mm, h - 12 * mm, BRAND)
+                self.drawRightString(w - 18 * mm, h - 12 * mm, "AI WRITING REPORT")
+                if not summary_only:
+                    self.drawCentredString(w / 2, 10 * mm, f"Page {self._pageNumber} of {total}")
+                super().showPage()
+            super().save()
+
+    _n = [0]
+    def S(**k):
+        _n[0] += 1
+        return ParagraphStyle(name=f"s{_n[0]}", **k)
+
+    body = S(fontName=serif, fontSize=12, leading=24, alignment=4, firstLineIndent=18)
+    head = S(fontName=serif_b, fontSize=12, leading=22, spaceBefore=8, spaceAfter=2)
+    plain = S(fontName=serif, fontSize=11, leading=16, textColor=colors.HexColor("#333333"), spaceAfter=6)
+    tbls = S(fontName=serif, fontSize=9, leading=12, textColor=colors.HexColor("#555555"), spaceAfter=6)
+    h1 = S(fontName=sans_b, fontSize=26, leading=32, spaceAfter=6)
+    h2 = S(fontName=sans_b, fontSize=12, leading=16, spaceBefore=12, spaceAfter=4)
+    small = S(fontName=sans, fontSize=9.5, leading=13.5, textColor=colors.HexColor("#333333"))
+    esc = lambda t: html.escape(t, quote=False)
+    cell = S(fontName=serif, fontSize=9.5, leading=12)
+    cell_b = S(fontName=serif_b, fontSize=9.5, leading=12)
+
+    def make_table(rows):
+        ncol = max(len(r) for r in rows)
+        rows = [r + [""] * (ncol - len(r)) for r in rows]
+        # column widths proportional to content length, within page width
+        lens = [max(min(len(r[c]), 60) for r in rows) + 4 for c in range(ncol)]
+        W = 160 * mm
+        widths = [W * l / sum(lens) for l in lens]
+        data = [[Paragraph(esc(c), cell_b if i == 0 else cell) for c in r] for i, r in enumerate(rows)]
+        t = Table(data, colWidths=widths, repeatRows=1, hAlign="CENTER")
+        t.setStyle(TableStyle([
+            ("GRID", (0, 0), (-1, -1), 0.4, colors.HexColor("#9a9a9a")),
+            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#efefef")),
+            ("VALIGN", (0, 0), (-1, -1), "TOP"),
+            ("TOPPADDING", (0, 0), (-1, -1), 3), ("BOTTOMPADDING", (0, 0), (-1, -1), 3),
+            ("LEFTPADDING", (0, 0), (-1, -1), 4), ("RIGHTPADDING", (0, 0), (-1, -1), 4)]))
+        t.spaceBefore, t.spaceAfter = 4, 10
+        return t
+
+    story = [Spacer(1, 10), Paragraph(f"{stats['pct']}% detected as AI", h1),
+             Paragraph("The percentage indicates the share of analysed text that the detector classified as "
+                       "likely AI-generated (high plus moderate likelihood).", small),
+             Paragraph(f"<b>{band(stats['pct'])}</b>", S(fontName=sans, fontSize=10.5, leading=16, spaceBefore=6)),
+             Paragraph("Important Notice", h2),
+             Paragraph("This percentage is a probabilistic estimate from a machine-learning classifier and should be "
+                       "treated as an indicator, not a conclusion. Results vary with writing style, subject matter, "
+                       "non-native English and document structure, and false positives occur. Use this report as "
+                       "one reference point alongside human judgement.", small),
+             Paragraph("Guidelines", h2),
+             Paragraph("The report analyses long-form prose. Highlight colours show the likelihood of a passage being "
+                       "flagged: cyan for high, light purple for moderate, unhighlighted for low. Non-qualifying "
+                       "content (headings, short bullet points, tables, captions, references) is not analysed. "
+                       "Scanned or image-only pages cannot be read.", small),
+             Paragraph("Details", h2)]
+    t = Table([["File", esc(fname)[:60]], ["Word count", f"{stats['all_words']:,}"],
+               ["Words analysed", f"{stats['analysed']:,}"], ["Document size", f"{fsize_kb:.1f} KB"],
+               ["Detector", MODEL_ID]], colWidths=[40 * mm, 110 * mm])
+    t.setStyle(TableStyle([("FONT", (0, 0), (-1, -1), sans, 9.5), ("FONT", (0, 0), (0, -1), sans_b, 9.5),
+                           ("BOTTOMPADDING", (0, 0), (-1, -1), 3)]))
+    story += [t, Paragraph("Score Interpretation", h2)]
+    t = Table([["0% – 19%", "Low likelihood of AI-generated content"],
+               ["20% – 50%", "Moderate likelihood of AI-generated content"],
+               ["51% – 100%", "High likelihood of AI-generated content"]], colWidths=[30 * mm, 120 * mm])
+    t.setStyle(TableStyle([("FONT", (0, 0), (-1, -1), sans, 9.5), ("BOTTOMPADDING", (0, 0), (-1, -1), 3)]))
+    story += [t, Paragraph("Highlight Legend", h2)]
+    t = Table([["", f"High likelihood of being flagged (≥ {hi:.0%})"],
+               ["", f"Moderate likelihood of being flagged ({mod:.0%} – {hi:.0%})"],
+               ["", f"Low likelihood of being flagged (< {mod:.0%})"]],
+              colWidths=[10 * mm, 140 * mm], rowHeights=6 * mm)
+    t.setStyle(TableStyle([("FONT", (0, 0), (-1, -1), sans, 9.5),
+                           ("BACKGROUND", (0, 0), (0, 0), colors.HexColor(HIGH_COLOR)),
+                           ("BACKGROUND", (0, 1), (0, 1), colors.HexColor(MOD_COLOR)),
+                           ("BOX", (0, 2), (0, 2), 0.5, colors.HexColor("#999999")),
+                           ("VALIGN", (0, 0), (-1, -1), "MIDDLE")]))
+    story += [t, Spacer(1, 14), Paragraph(f"Report generated: {now}", small)]
+    if summary_only:
+        blocks = []
+    else:
+        story.append(PageBreak())
+
+    for b in blocks:
+        if b.kind == "para":
+            parts = []
+            for s, p in zip(b.sents, b.scores):
+                s = esc(s)
+                if p >= hi:
+                    s = f'<font backColor="{HIGH_COLOR}">{s}</font>'
+                elif p >= mod:
+                    s = f'<font backColor="{MOD_COLOR}">{s}</font>'
+                parts.append(s)
+            story.append(Paragraph(" ".join(parts), body))
+        elif b.kind == "heading":
+            story.append(Paragraph(esc(b.text), head))
+        elif b.kind == "table" and b.rows:
+            story.append(make_table(b.rows))
+        elif b.kind == "table":
+            story.append(Paragraph(esc(b.text).replace("\n", "<br/>"), tbls))
+        else:
+            story.append(Paragraph(esc(b.text), plain))
+
+    doc = BaseDocTemplate(out_path, pagesize=A4, leftMargin=25 * mm, rightMargin=25 * mm,
+                          topMargin=22 * mm, bottomMargin=20 * mm, title="AI Writing Report")
+    doc.addPageTemplates([PageTemplate(id="p", frames=[
+        Frame(doc.leftMargin, doc.bottomMargin, doc.width, doc.height, id="f")])])
+    doc.build(story, canvasmaker=NumberedCanvas)
+    return out_path
+
+def build_overlay_pdf(src_pdf, blocks, stats, fname, fsize_kb, hi, mod, out_path):
+    """Summary page + the ORIGINAL pages with highlight annotations."""
+    import pymupdf as fitz
+    rgb = lambda hx: tuple(int(hx[i:i + 2], 16) / 255 for i in (1, 3, 5))
+    hc, mc = rgb(HIGH_COLOR), rgb(MOD_COLOR)
+    src = fitz.open(src_pdf)
+    pages = {}                       # keep Page objects alive while annotating
+    for b in blocks:
+        if b.kind != "para" or not b.spans:
+            continue
+        for (a, e), p in zip(b.spans, b.scores):
+            if p < mod:
+                continue
+            col = hc if p >= hi else mc
+            lines = {}
+            for pno, bno, lno, bbox in b.toks[a:e]:
+                key = (pno, bno, lno)
+                lines[key] = lines[key] | fitz.Rect(bbox) if key in lines else fitz.Rect(bbox)
+            for (pno, _, _), r in lines.items():
+                pg = pages.get(pno) or pages.setdefault(pno, src[pno])
+                an = pg.add_highlight_annot(r)
+                an.set_colors(stroke=col)
+                an.update()
+
+    summ = out_path + ".summary.pdf"
+    build_pdf([], stats, fname, fsize_kb, hi, mod, summ, summary_only=True)
+    final = fitz.open(summ)
+    n_summary = len(final)
+    final.insert_pdf(src, annots=True)
+    n = len(final)
+    grey = (0.35, 0.35, 0.35)
+    for i, page in enumerate(final):
+        if page.rotation:
+            continue
+        w, h = page.rect.width, page.rect.height
+        label = f"Page {i + 1} of {n}"
+        page.insert_text(((w - fitz.get_text_length(label, fontsize=7)) / 2, h - 8), label,
+                         fontsize=7, color=grey, overlay=True)
+        if i >= n_summary:
+            page.insert_text((20, 11), BRAND, fontsize=6.5, color=grey, overlay=True)
+            rt = "AI WRITING REPORT"
+            page.insert_text((w - 20 - fitz.get_text_length(rt, fontsize=6.5), 11), rt,
+                             fontsize=6.5, color=grey, overlay=True)
+    final.save(out_path, garbage=3, deflate=True)
+    final.close(); src.close()
+    os.remove(summ)
+    return out_path
+
+# ---------------------------------------------------------------- HTML preview
+def build_html(blocks, stats, hi, mod):
+    col = "#c0392b" if stats["pct"] > 50 else "#d68910" if stats["pct"] >= 20 else "#1e8449"
+    out = [f"""<div style="font-family:system-ui;padding:14px 18px;border:1px solid #ddd;border-radius:10px;margin-bottom:12px">
+<div style="font-size:34px;font-weight:700;color:{col}">{stats['pct']}% detected as AI</div>
+<div style="color:#555">{band(stats['pct'])} · {stats['analysed']:,} of {stats['all_words']:,} words analysed</div>
+<div style="margin-top:6px;font-size:13px;color:#111"><span style="background:{HIGH_COLOR};padding:1px 8px">High</span>
+<span style="background:{MOD_COLOR};padding:1px 8px">Moderate</span>
+<span style="padding:1px 8px;border:1px solid #ccc">Low</span></div></div>
+<div style="font-family:Georgia,serif;line-height:1.9;max-height:640px;overflow:auto;padding:4px 12px;color:#111;background:#fff;border-radius:8px">"""]
+    for b in blocks:
+        if b.kind == "para":
+            segs = []
+            for s, p in zip(b.sents, b.scores):
+                bg = HIGH_COLOR if p >= hi else MOD_COLOR if p >= mod else "transparent"
+                segs.append(f'<span title="P(AI) = {p:.2f}" style="background:{bg}">{html.escape(s)}</span>')
+            out.append("<p style='text-align:justify'>" + " ".join(segs) + "</p>")
+        elif b.kind == "heading":
+            out.append(f"<p><b>{html.escape(b.text)}</b></p>")
+        elif b.kind == "table" and b.rows:
+            td = "border:1px solid #bbb;padding:3px 8px;text-align:left;vertical-align:top"
+            trs = []
+            for i, r in enumerate(b.rows):
+                tag = "th" if i == 0 else "td"
+                bg = "background:#f0f0f0;" if i == 0 else ""
+                trs.append("<tr>" + "".join(f"<{tag} style='{bg}{td}'>{html.escape(c)}</{tag}>" for c in r) + "</tr>")
+            out.append("<table style='border-collapse:collapse;margin:6px auto 14px;font-size:0.88em'>"
+                       + "".join(trs) + "</table>")
+        else:
+            out.append(f"<p style='color:#777;font-size:0.9em'>{html.escape(b.text).replace(chr(10), '<br>')}</p>")
+    out.append("</div>")
+    return "".join(out)
+
+# ---------------------------------------------------------------- pipeline
+def load_blocks(file, pasted):
+    """Returns (blocks, fname, size_kb, source_pdf_or_None, docx_document_or_None)."""
+    src_pdf, doc = None, None
+    if file is not None:
+        path = file if isinstance(file, str) else file.name
+        ext = os.path.splitext(path)[1].lower()
+        fname, size_kb = os.path.basename(path), os.path.getsize(path) / 1024
+        if ext == ".docx":
+            try:
+                doc = DX.open_clean(path)
+            except Exception:
+                raise gr.Error("Could not open this .docx (is it a valid Word file, not .doc?).")
+            blocks = extract_docx_live(doc)
+        elif ext == ".pdf":
+            src_pdf = path
+            blocks = extract_pdf_layout(path)
+        elif ext in (".txt", ".md"):
+            with open(path, encoding="utf-8", errors="ignore") as fh:
+                blocks = extract_text(fh.read())
+        else:
+            raise gr.Error("Upload a .docx, .pdf or .txt file.")
+    elif pasted and pasted.strip():
+        blocks, fname, size_kb = extract_text(pasted), "Pasted text", len(pasted.encode()) / 1024
+    else:
+        raise gr.Error("Upload a file or paste text.")
+    return classify(blocks), fname, size_kb, src_pdf, doc
+
+def run(file, pasted, hi, mod, progress=gr.Progress()):
+    if mod >= hi:
+        raise gr.Error("Moderate threshold must be below the high threshold.")
+    progress(0.05, desc="Reading document")
+    blocks, fname, size_kb, src_pdf, doc = load_blocks(file, pasted)
+    if not any(b.kind == "para" for b in blocks):
+        raise gr.Error("No qualifying prose found (needs paragraphs of 25+ words). "
+                       "Scanned/image-only PDFs have no readable text.")
+    progress(0.2, desc="Running detector")
+    blocks = analyse(blocks)
+    stats = summarise(blocks, hi, mod)
+    base = re.sub(r"[^\w\-]+", "_", os.path.splitext(fname)[0])[:40] or "document"
+    work = tempfile.mkdtemp()
+    pdf = os.path.join(work, f"AI_Report_{base}.pdf")
+    warn = ""
+
+    if doc is not None:                                   # ---- Word: inject, then render
+        progress(0.7, desc="Highlighting the Word file")
+        for b in blocks:
+            if b.kind == "para" and b.el is not None and b.cspans:
+                spans = [(sp[0], sp[1], (HIGH_COLOR if p >= hi else MOD_COLOR).lstrip("#"))
+                         for sp, p in zip(b.cspans, b.scores) if sp and p >= mod]
+                DX.colour_paragraph(b.el, spans)
+        docx_tmp = os.path.join(work, f"{base}_highlighted.docx")
+        doc.save(docx_tmp)
+        progress(0.8, desc="Converting to PDF")
+        rendered = DX.convert_to_pdf(docx_tmp)
+        if rendered:
+            want, got = DX.count_docx_pictures(doc), DX.count_pdf_images(rendered)
+            if got < want:
+                warn = (f"{want - got} of {want} pictures from the Word file did not render in the PDF. "
+                        "For a report identical to Word, save the manuscript as PDF from Word "
+                        "and upload that PDF instead.")
+            progress(0.9, desc="Building report")
+            build_overlay_pdf(rendered, [], stats, fname, size_kb, hi, mod, pdf)
+        else:
+            warn = ("Word-to-PDF conversion failed, so this report is re-typeset text without "
+                    "figures/equations. Reason: " + (DX.LAST_ERROR or "unknown") +
+                    " — Workaround: save the manuscript as PDF from Word and upload the PDF.")
+            build_pdf(blocks, stats, fname, size_kb, hi, mod, pdf)
+    elif src_pdf:                                         # ---- PDF: annotate original pages
+        progress(0.85, desc="Building report")
+        build_overlay_pdf(src_pdf, blocks, stats, fname, size_kb, hi, mod, pdf)
+    else:                                                 # ---- plain text
+        progress(0.85, desc="Building report")
+        build_pdf(blocks, stats, fname, size_kb, hi, mod, pdf)
+
+    page = build_html(blocks, stats, hi, mod)
+    if warn:
+        page = (f"<div style='font-family:system-ui;background:#fff4e5;border:1px solid #f0b458;"
+                f"color:#6b4400;padding:10px 14px;border-radius:8px;margin-bottom:10px'>⚠ {html.escape(warn)}</div>"
+                + page)
+    return page, pdf

docx_report.py

@@ -0,0 +1,360 @@
+"""
+Word (.docx) pipeline for the AI Writing Report Space.
+
+1. Clean:   remove empty numbered paragraphs (Word hides them, LibreOffice prints them).
+2. Read:    paragraphs in document order, keeping a reference to each paragraph's XML.
+3. Inject:  after scoring, colour each sentence directly in the original .docx
+            (run-level shading) -> the Word file keeps 100 % of its structure.
+4. Render:  convert the highlighted .docx to PDF with the newest LibreOffice available.
+5. Check:   compare pictures in the .docx with images in the PDF and warn if any are lost.
+"""
+import os, re, copy, glob, shutil, tarfile, tempfile, threading, subprocess, urllib.request
+
+from docx import Document
+from docx.oxml.ns import qn
+
+W_R, W_T = qn("w:r"), qn("w:t")
+SKIP_ANCESTORS = {qn("w:txbxContent"), qn("w:del"), qn("w:moveFrom"),
+                  "{http://schemas.openxmlformats.org/markup-compatibility/2006}Fallback"}
+
+# ============================================================ LibreOffice
+LO_HOME = os.path.expanduser(os.getenv("LO_DIR", "~/lo-fresh"))
+_lo_exe = None
+_lo_ready = threading.Event()
+
+
+def _lo_version(exe):
+    try:
+        out = subprocess.run([exe, "--version"], capture_output=True, text=True, timeout=60).stdout
+        m = re.search(r"(\d+)\.(\d+)", out)
+        return (int(m.group(1)), int(m.group(2))) if m else (0, 0)
+    except Exception:
+        return (0, 0)
+
+
+def _fetch_fresh_lo():
+    """Download the current stable LibreOffice .deb bundle from TDF and unpack it
+    without root (dpkg-deb -x). Newer releases import Word layouts far better than
+    the Debian package (floating images, wrapping, grouped shapes, SmartArt)."""
+    found = glob.glob(os.path.join(LO_HOME, "opt", "libreoffice*", "program", "soffice"))
+    if found:
+        return found[0]
+    base = "https://download.documentfoundation.org/libreoffice/stable/"
+    idx = urllib.request.urlopen(base, timeout=60).read().decode()
+    vers = sorted(set(re.findall(r'href="(\d+\.\d+\.\d+)/"', idx)),
+                  key=lambda v: tuple(map(int, v.split("."))))
+    if not vers:
+        return None
+    v = vers[-1]
+    url = f"{base}{v}/deb/x86_64/LibreOffice_{v}_Linux_x86-64_deb.tar.gz"
+    tmp = tempfile.mkdtemp()
+    tgz = os.path.join(tmp, "lo.tgz")
+    with urllib.request.urlopen(url, timeout=600) as r, open(tgz, "wb") as f:
+        shutil.copyfileobj(r, f)
+    with tarfile.open(tgz) as t:
+        t.extractall(tmp)
+    os.makedirs(LO_HOME, exist_ok=True)
+    for deb in glob.glob(os.path.join(tmp, "*", "DEBS", "*.deb")):
+        subprocess.run(["dpkg-deb", "-x", deb, LO_HOME], check=True, capture_output=True)
+    shutil.rmtree(tmp, ignore_errors=True)
+    found = glob.glob(os.path.join(LO_HOME, "opt", "libreoffice*", "program", "soffice"))
+    return found[0] if found else None
+
+
+def _init_lo():
+    global _lo_exe
+    system = shutil.which("soffice") or shutil.which("libreoffice")
+    best, best_v = system, _lo_version(system) if system else (0, 0)
+    if os.getenv("LO_AUTO_UPDATE", "0") == "1":
+        try:
+            fresh = _fetch_fresh_lo()
+            fv = _lo_version(fresh) if fresh else (0, 0)
+            if fv > best_v:
+                best, best_v = fresh, fv
+        except Exception as e:
+            print(f"[docx] fresh LibreOffice unavailable ({e}); using system build", flush=True)
+    _lo_exe = best
+    print(f"[docx] LibreOffice for rendering: {best} version {best_v}", flush=True)
+    _lo_ready.set()
+    self_test()
+
+
+def start_lo_init():
+    threading.Thread(target=_init_lo, daemon=True).start()
+
+
+def lo_exe(wait=300):
+    _lo_ready.wait(wait)
+    return _lo_exe or shutil.which("soffice") or shutil.which("libreoffice")
+
+
+LAST_ERROR = ""
+
+
+def convert_to_pdf(docx_path):
+    """DOCX -> PDF. Two attempts with a private LibreOffice profile; the reason for any
+    failure is kept in LAST_ERROR so the app can show it."""
+    global LAST_ERROR
+    LAST_ERROR = ""
+    exe = lo_exe()
+    if not exe:
+        LAST_ERROR = "LibreOffice is not installed on the Space (check packages.txt and the build log)."
+        print("[docx] " + LAST_ERROR, flush=True)
+        return None
+    for attempt, target in enumerate(("pdf:writer_pdf_Export", "pdf")):
+        out = tempfile.mkdtemp()
+        profile = tempfile.mkdtemp()
+        cmd = [exe, f"-env:UserInstallation=file://{profile}", "--headless", "--invisible",
+               "--nodefault", "--nologo", "--norestore", "--nolockcheck",
+               "--convert-to", target, "--outdir", out, docx_path]
+        try:
+            r = subprocess.run(cmd, timeout=420, capture_output=True, text=True,
+                               env={**os.environ, "HOME": profile, "SAL_USE_VCLPLUGIN": "svp"})
+            pdf = os.path.join(out, os.path.splitext(os.path.basename(docx_path))[0] + ".pdf")
+            if os.path.exists(pdf) and os.path.getsize(pdf) > 0:
+                return pdf
+            LAST_ERROR = (f"LibreOffice exit {r.returncode}: " + (r.stderr or r.stdout or "")[-600:]).strip()
+        except subprocess.TimeoutExpired:
+            LAST_ERROR = "LibreOffice timed out while converting the document."
+        except Exception as e:
+            LAST_ERROR = f"LibreOffice could not run: {e}"
+        print(f"[docx] conversion attempt {attempt + 1} failed: {LAST_ERROR}", flush=True)
+    return None
+
+
+def self_test():
+    """Convert a one-line document at startup and log whether rendering works."""
+    try:
+        d = Document()
+        d.add_paragraph("LibreOffice self-test.")
+        p = os.path.join(tempfile.mkdtemp(), "selftest.docx")
+        d.save(p)
+        ok = convert_to_pdf(p)
+        print(f"[docx] self-test: {'OK' if ok else 'FAILED - ' + LAST_ERROR}", flush=True)
+    except Exception as e:
+        print(f"[docx] self-test error: {e}", flush=True)
+
+
+# ============================================================ reading
+def _skip_run(r):
+    a = r.getparent()
+    while a is not None:
+        if a.tag in SKIP_ANCESTORS:
+            return True
+        a = a.getparent()
+    return False
+
+
+def para_runs(p_el):
+    """Visible w:r elements of a paragraph, in order (hyperlinks/fields included,
+    text boxes / deleted text excluded)."""
+    return [r for r in p_el.iter(W_R) if not _skip_run(r)]
+
+
+def run_text(r):
+    out = []
+    for c in r:
+        tag = c.tag
+        if tag == W_T:
+            out.append(c.text or "")
+        elif tag == qn("w:tab"):
+            out.append("\t")
+        elif tag in (qn("w:br"), qn("w:cr")):
+            out.append("\n")
+        elif tag == qn("w:noBreakHyphen"):
+            out.append("-")
+    return "".join(out)
+
+
+def para_text(p_el):
+    return "".join(run_text(r) for r in para_runs(p_el))
+
+
+def _numbered(p, doc):
+    pPr = p._p.pPr
+    if pPr is not None and pPr.find(qn("w:numPr")) is not None:
+        return True
+    st = p.style
+    while st is not None:
+        sp = st.element.find(qn("w:pPr"))
+        if sp is not None and sp.find(qn("w:numPr")) is not None:
+            return True
+        st = st.base_style
+    return False
+
+
+def _empty(p):
+    if para_text(p._p).strip():
+        return False
+    for tag in ("w:drawing", "w:pict", "w:object"):
+        if p._p.findall(".//" + qn(tag)):
+            return False
+    if p._p.xpath(".//*[local-name()='oMath' or local-name()='oMathPara']"):
+        return False
+    return True
+
+
+def _neutralise(p):
+    """Keep an empty numbered paragraph (it advances the list counter, so later heading
+    numbers stay correct) but make it invisible: white 1-pt label, zero line height."""
+    from docx.oxml import parse_xml
+    W = 'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"'
+    pPr = p._p.get_or_add_pPr()
+    for old in pPr.findall(qn("w:spacing")) + pPr.findall(qn("w:rPr")):
+        pPr.remove(old)
+    sp = parse_xml(f'<w:spacing {W} w:before="0" w:after="0" w:line="20" w:lineRule="exact"/>')
+    anchor = next((c for c in pPr if c.tag in {qn("w:ind"), qn("w:contextualSpacing"), qn("w:jc"),
+                                               qn("w:outlineLvl"), qn("w:sectPr"), qn("w:pPrChange")}), None)
+    if anchor is not None:
+        anchor.addprevious(sp)
+    else:
+        pPr.append(sp)
+    rpr = parse_xml(f'<w:rPr {W}><w:color w:val="FFFFFF"/><w:sz w:val="2"/><w:szCs w:val="2"/></w:rPr>')
+    tail = next((c for c in pPr if c.tag in {qn("w:sectPr"), qn("w:pPrChange")}), None)
+    if tail is not None:
+        tail.addprevious(rpr)
+    else:
+        pPr.append(rpr)
+
+
+OUR_FILLS = {"A9E4EE", "E4DCF5"}
+
+
+def open_clean(path):
+    """Open the .docx, hide empty numbered paragraphs (without breaking numbering) and
+    remove highlight shading left over from a previous report."""
+    doc = Document(path)
+    paras = list(doc.paragraphs)
+    for t in doc.tables:
+        for row in t.rows:
+            for cell in row.cells:
+                paras += cell.paragraphs
+    for p in paras:
+        try:
+            if _empty(p) and _numbered(p, doc):
+                _neutralise(p)
+        except Exception:
+            pass
+    for shd in doc.element.body.iter(qn("w:shd")):
+        if (shd.get(qn("w:fill")) or "").upper() in OUR_FILLS and shd.getparent().tag == qn("w:rPr"):
+            shd.getparent().remove(shd)
+    return doc
+
+
+def iter_body(doc):
+    """Yields ('p', Paragraph) or ('tbl', Table) in body order."""
+    from docx.text.paragraph import Paragraph
+    from docx.table import Table
+    for child in doc.element.body.iterchildren():
+        tag = child.tag.split("}")[-1]
+        if tag == "p":
+            yield "p", Paragraph(child, doc)
+        elif tag == "tbl":
+            yield "tbl", Table(child, doc)
+
+
+# ============================================================ injection
+_RPR_AFTER_SHD = {qn(t) for t in ("w:fitText", "w:vertAlign", "w:rtl", "w:cs", "w:em", "w:lang",
+                                  "w:eastAsianLayout", "w:specVanish", "w:oMath")}
+
+
+def _shade(r, fill):
+    rPr = r.find(qn("w:rPr"))
+    if rPr is None:
+        rPr = r.makeelement(qn("w:rPr"), {})
+        r.insert(0, rPr)
+    for old in rPr.findall(qn("w:shd")) + rPr.findall(qn("w:highlight")):
+        rPr.remove(old)
+    shd = rPr.makeelement(qn("w:shd"), {qn("w:val"): "clear", qn("w:color"): "auto", qn("w:fill"): fill})
+    pos = next((i for i, c in enumerate(rPr) if c.tag in _RPR_AFTER_SHD), len(rPr))
+    rPr.insert(pos, shd)
+
+
+def _simple(r):
+    kids = [c for c in r if c.tag != qn("w:rPr")]
+    return len(kids) == 1 and kids[0].tag == W_T
+
+
+def _split_simple(r, cuts):
+    """Split a single-text run at relative offsets; returns the new runs in order."""
+    t = r.find(W_T).text or ""
+    pts = [0] + sorted(c for c in set(cuts) if 0 < c < len(t)) + [len(t)]
+    if len(pts) == 2:
+        return [r]
+    parent, idx = r.getparent(), r.getparent().index(r)
+    new = []
+    for a, b in zip(pts, pts[1:]):
+        nr = copy.deepcopy(r)
+        te = nr.find(W_T)
+        te.text = t[a:b]
+        te.set("{http://www.w3.org/XML/1998/namespace}space", "preserve")
+        new.append(nr)
+    parent.remove(r)
+    for i, nr in enumerate(new):
+        parent.insert(idx + i, nr)
+    return new
+
+
+def colour_paragraph(p_el, spans):
+    """spans: list of (start, end, hex_fill) character ranges on para_text(p_el)."""
+    if not spans:
+        return
+    cuts = sorted({x for a, b, _ in spans for x in (a, b)})
+    pos = 0
+    pieces = []                                   # (run, start, end)
+    for r in para_runs(p_el):
+        t = run_text(r)
+        s, e = pos, pos + len(t)
+        pos = e
+        if not t:
+            continue
+        if _simple(r):
+            rel = [c - s for c in cuts if s < c < e]
+            off = s
+            for nr in _split_simple(r, rel):
+                ln = len(nr.find(W_T).text or "")
+                pieces.append((nr, off, off + ln))
+                off += ln
+        else:
+            pieces.append((r, s, e))
+    for r, s, e in pieces:
+        mid = (s + e) / 2
+        for a, b, fill in spans:
+            if a <= mid < b:
+                _shade(r, fill)
+                break
+
+
+def sentence_char_spans(raw, sentences):
+    """Locate each sentence (a stripped substring of raw) in order."""
+    out, cur = [], 0
+    for s in sentences:
+        i = raw.find(s, cur)
+        if i < 0:                                 # whitespace differences -> fuzzy fallback
+            first = s.split()[0] if s.split() else s
+            i = raw.find(first, cur)
+            if i < 0:
+                out.append(None)
+                continue
+            j = i + len(s)
+        else:
+            j = i + len(s)
+        out.append((i, j))
+        cur = j
+    return out
+
+
+# ============================================================ figure check
+def count_docx_pictures(doc):
+    body = doc.element.body
+    return len(body.xpath(".//*[local-name()='blip']")) + len(body.xpath(".//*[local-name()='imagedata']"))
+
+
+def count_pdf_images(pdf_path):
+    import pymupdf
+    seen = set()
+    with pymupdf.open(pdf_path) as d:
+        for p in d:
+            for img in p.get_images(full=True):
+                seen.add(img[0])
+    return len(seen)

humanizer.py

@@ -0,0 +1,592 @@
+"""Humanizer engine (Parrot T5 paraphraser) + stylometric indicators + DOCX helpers."""
+import base64
+import hashlib
+import hmac
+import secrets
+import sqlite3
+import os
+import re
+import statistics
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+import gradio as gr
+import torch
+
+try:  # ZeroGPU (HF Pro); falls back to plain CPU/GPU hardware
+    import spaces
+    _GPU = spaces.GPU
+except Exception:  # pragma: no cover
+    spaces = None
+    def _GPU(duration=None):
+        return lambda fn: fn
+from docx import Document
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+
+# ---------------------------------------------------------------------------
+# Brand (colours sampled from the CS Software Solutions logo)
+# ---------------------------------------------------------------------------
+BRAND = {
+    "navy": "#07228B",
+    "purple": "#47148B",
+    "magenta": "#E92E7F",
+    "red": "#E12B41",
+    "orange": "#FE5828",
+    "yellow": "#F5C518",
+    "green": "#50BF49",
+    "sky": "#50B4EF",
+    "grey": "#4A4A4A",
+}
+RAINBOW = (
+    f"linear-gradient(90deg, {BRAND['purple']}, {BRAND['navy']}, {BRAND['sky']}, "
+    f"{BRAND['green']}, {BRAND['yellow']}, {BRAND['orange']}, {BRAND['red']}, {BRAND['magenta']})"
+)
+APP_NAME = "CS Academic Paraphraser"
+SITE_URL = "https://cssoftwaresolutions.in"
+
+LOGO_PATH = Path(__file__).parent / "logo.png"
+LOGO_SRC = ""
+FAVICON_PATH = Path(__file__).parent / "favicon.png"
+FAVICON_SRC = ""
+if FAVICON_PATH.exists():
+    FAVICON_SRC = "data:image/png;base64," + base64.b64encode(FAVICON_PATH.read_bytes()).decode()
+if LOGO_PATH.exists():
+    LOGO_SRC = "data:image/png;base64," + base64.b64encode(LOGO_PATH.read_bytes()).decode()
+
+# ---------------------------------------------------------------------------
+# Model (kept in CPU RAM while idle; moved to GPU only inside @spaces.GPU)
+# ---------------------------------------------------------------------------
+MODEL_ID = os.getenv("PARROT_MODEL", "prithivida/parrot_paraphraser_on_T5")
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_ID).eval()
+model_lock = threading.Lock()
+
+GPU_CHUNK = 48          # sentences per ZeroGPU allocation (short reservations)
+CPU_CHUNK = 16          # sentences per CPU step (keeps progress updating)
+OUT_DIR = Path(tempfile.gettempdir()) / "cs_outputs"
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+MODES = ["Auto (GPU, falls back to CPU)", "CPU only (no GPU quota)"]
+MAX_PASTE_WORDS = int(os.getenv("MAX_PASTE_WORDS", "6000"))  # keeps a single paste request within quota
+
+
+# ---------------------------------------------------------------------------
+# Text helpers
+# ---------------------------------------------------------------------------
+def split_sentences(text):
+    parts = re.split(r"(?<=[.!?])\s+(?=[A-Z0-9\"'(\[])", text.strip())
+    return [p.strip() for p in parts if p.strip()]
+
+
+def should_process(text, min_words):
+    text = (text or "").strip()
+    if len(text.split()) < int(min_words):
+        return False
+    if re.fullmatch(r"https?://\S+|www\.\S+|\S+@\S+\.\S+", text):
+        return False
+    alpha = sum(ch.isalpha() for ch in text)
+    if alpha < max(5, int(len(text) * 0.35)):
+        return False
+    return True
+
+
+def words(text):
+    return re.findall(r"[A-Za-z0-9']+", (text or "").lower())
+
+
+# ---------------------------------------------------------------------------
+# Tentative indicators (local heuristics — NOT Turnitin / iThenticate / GPTZero)
+# ---------------------------------------------------------------------------
+def _ngrams(tokens, n):
+    return {tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1)}
+
+
+def similarity_to_source(original, revised):
+    """Share of the revised text's word n-grams that also occur in the original."""
+    a, b = words(original), words(revised)
+    if len(b) < 4 or len(a) < 4:
+        return 0.0
+    scores, weights = [], []
+    for n, w in ((2, 0.2), (3, 0.35), (4, 0.45)):
+        gb = _ngrams(b, n)
+        if not gb:
+            continue
+        scores.append(len(gb & _ngrams(a, n)) / len(gb))
+        weights.append(w)
+    if not weights:
+        return 0.0
+    return 100.0 * sum(s * w for s, w in zip(scores, weights)) / sum(weights)
+
+
+AI_MARKERS = [
+    "delve", "delves", "delving", "furthermore", "moreover", "additionally",
+    "in conclusion", "it is important to note", "it is worth noting", "plays a crucial role",
+    "plays a pivotal role", "pivotal", "crucial", "comprehensive", "leverage", "leveraging",
+    "seamless", "seamlessly", "robust", "landscape", "underscore", "underscores",
+    "notably", "in today's", "fostering", "foster", "multifaceted", "intricate",
+    "realm", "tapestry", "navigate", "navigating", "holistic", "paramount",
+    "a testament to", "shed light", "sheds light", "ever-evolving", "cutting-edge",
+    "in the realm of", "overall,", "ultimately", "enhance", "enhancing", "streamline",
+    "valuable insights", "key role", "vital role", "significantly",
+]
+
+
+def ai_likelihood(text):
+    """Stylometric estimate (0–100) of machine-like writing."""
+    toks = words(text)
+    if len(toks) < 30:
+        return None
+    sents = split_sentences(text) or [text]
+    lengths = [len(words(s)) for s in sents if words(s)]
+
+    # 1. Burstiness: humans vary sentence length more than LLMs.
+    if len(lengths) >= 3:
+        cv = statistics.pstdev(lengths) / max(1.0, statistics.mean(lengths))
+        burst = min(1.0, max(0.0, (0.60 - cv) / 0.45))
+    else:
+        burst = 0.5
+
+    # 2. Density of stock "LLM" vocabulary per 100 words.
+    low = " " + " ".join(toks) + " "
+    raw = (text or "").lower()
+    hits = sum(raw.count(m) if " " in m or "," in m else low.count(f" {m} ") for m in AI_MARKERS)
+    marker = min(1.0, (hits / len(toks) * 100) / 2.5)
+
+    # 3. Uniformity: mid-length sentences, repeated openers, low lexical variety.
+    mean_len = statistics.mean(lengths)
+    band = 1.0 if 16 <= mean_len <= 28 else 0.4
+    openers = [words(s)[0] for s in sents if words(s)]
+    repeat = 1 - len(set(openers)) / len(openers) if openers else 0
+    window = toks[:400]
+    ttr = len(set(window)) / len(window)
+    variety = min(1.0, max(0.0, (0.62 - ttr) / 0.25))
+    uniform = 0.45 * band + 0.3 * min(1.0, repeat * 2) + 0.25 * variety
+
+    score = 100 * (0.40 * burst + 0.35 * marker + 0.25 * uniform)
+    return float(max(3.0, min(97.0, score)))
+
+
+def words_changed(original, revised):
+    a, b = words(original), words(revised)
+    if not b:
+        return 0.0
+    return 100.0 * (1 - len(set(b) & set(a)) / len(set(b)))
+
+
+def _level(value, invert=False):
+    if value is None:
+        return "#9aa0a6", "n/a"
+    v = 100 - value if invert else value
+    if v < 30:
+        return BRAND["green"], "Low"
+    if v < 55:
+        return BRAND["orange"], "Moderate"
+    return BRAND["red"], "High"
+
+
+def _gauge(title, value, caption, invert=False, fixed_color=None):
+    color, label = _level(value, invert)
+    if fixed_color:
+        color = fixed_color
+        label = "Rewrite depth"
+    pct = 0 if value is None else round(value)
+    shown = "—" if value is None else f"{pct}%"
+    return f"""
+    <div class="cs-gauge">
+      <div class="cs-ring" style="--p:{pct};--c:{color}">
+        <div class="cs-ring-inner"><span>{shown}</span></div>
+      </div>
+      <div class="cs-gauge-title">{title}</div>
+      <div class="cs-chip" style="background:{color}1f;color:{color}">{label}</div>
+      <div class="cs-gauge-cap">{caption}</div>
+    </div>"""
+
+
+def score_panel(original, revised):
+    sim = similarity_to_source(original, revised)
+    ai_in = ai_likelihood(original)
+    ai_out = ai_likelihood(revised)
+    changed = words_changed(original, revised)
+    return f"""
+    <div class="cs-scores">
+      {_gauge("Similarity to source", sim, "Word n-gram overlap with your original")}
+      {_gauge("AI indicator · input", ai_in, "Stylometric estimate of the original")}
+      {_gauge("AI indicator · output", ai_out, "Stylometric estimate after paraphrasing")}
+      {_gauge("Vocabulary changed", changed, "Share of new wording", fixed_color=BRAND["navy"])}
+    </div>
+    <div class="cs-disclaimer">
+      <b>Tentative indicators only.</b> Similarity is measured against your own original text,
+      not against internet or journal databases, and the AI indicator is a stylometric heuristic.
+      Results will differ from Turnitin, iThenticate or other detectors. Always review the
+      output for meaning, technical terms and citations before use.
+    </div>"""
+
+
+EMPTY_SCORES = """
+<div class="cs-scores cs-empty">
+  <div>Scores appear here after paraphrasing — similarity to source, AI indicators and rewrite depth.</div>
+</div>"""
+
+
+# ---------------------------------------------------------------------------
+# DOCX structure helpers
+# ---------------------------------------------------------------------------
+def iter_table_paragraphs(table):
+    for row in table.rows:
+        for cell in row.cells:
+            for paragraph in cell.paragraphs:
+                yield paragraph
+            for nested_table in cell.tables:
+                yield from iter_table_paragraphs(nested_table)
+
+
+def collect_paragraphs(doc):
+    seen = set()
+
+    def unique(paragraphs):
+        for paragraph in paragraphs:
+            key = id(paragraph._p)
+            if key not in seen:
+                seen.add(key)
+                yield paragraph
+
+    yield from unique(doc.paragraphs)
+    for table in doc.tables:
+        yield from unique(iter_table_paragraphs(table))
+    for section in doc.sections:
+        for part in (
+            section.header, section.footer,
+            section.first_page_header, section.first_page_footer,
+            section.even_page_header, section.even_page_footer,
+        ):
+            yield from unique(part.paragraphs)
+            for table in part.tables:
+                yield from unique(iter_table_paragraphs(table))
+
+
+def _is_protected(run):
+    return bool(
+        run._r.xpath(".//w:drawing")
+        or run._r.xpath(".//w:object")
+        or run._r.xpath(".//w:fldChar")
+    )
+
+
+def replace_text_preserving_paragraph(paragraph, new_text):
+    runs = list(paragraph.runs)
+    if not runs:
+        paragraph.add_run(new_text)
+        return
+    target = next((r for r in runs if not _is_protected(r)), None)
+    if target is None:
+        target = paragraph.add_run()
+    target.text = new_text
+    for run in runs:
+        if run is not target and not _is_protected(run):
+            run.text = ""
+
+
+# ---------------------------------------------------------------------------
+# Paraphrasing
+# ---------------------------------------------------------------------------
+def _generate(texts, temperature, device, batch_size):
+    temperature = max(0.3, min(float(temperature), 1.5))
+    outputs = []
+    with torch.inference_mode():
+        for start in range(0, len(texts), batch_size):
+            chunk = texts[start:start + batch_size]
+            encoded = tokenizer(
+                ["paraphrase: " + t for t in chunk],
+                return_tensors="pt", padding=True, truncation=True, max_length=256,
+            )
+            encoded = {k: v.to(device) for k, v in encoded.items()}
+            generated = model.generate(
+                **encoded,
+                do_sample=True,
+                temperature=temperature,
+                top_p=0.92,
+                num_return_sequences=1,
+                max_new_tokens=180,
+                no_repeat_ngram_size=3,
+            )
+            decoded = tokenizer.batch_decode(generated.detach().cpu(), skip_special_tokens=True)
+            outputs.extend(c.strip() if c.strip() else s for s, c in zip(chunk, decoded))
+            del encoded, generated
+    return outputs
+
+
+def _gpu_duration(texts, temperature):
+    # Reserve only what this chunk needs, so visitors' daily ZeroGPU quota lasts longer.
+    return int(min(90, 12 + 0.3 * len(texts or [])))
+
+
+@_GPU(duration=_gpu_duration)
+def paraphrase_batch_gpu(texts, temperature):
+    if not texts:
+        return []
+    if not torch.cuda.is_available():
+        raise RuntimeError("GPU allocation did not expose CUDA.")
+    with model_lock:
+        model.to("cuda")
+        try:
+            return _generate(texts, temperature, "cuda", batch_size=16)
+        finally:
+            model.to("cpu")
+            torch.cuda.empty_cache()
+
+
+def paraphrase_batch_cpu(texts, temperature):
+    if not texts:
+        return []
+    with model_lock:
+        model.to("cpu")
+        return _generate(texts, temperature, "cpu", batch_size=4)
+
+
+def _is_gpu_unavailable(err):
+    msg = str(err).lower()
+    return any(k in msg for k in ("quota", "zerogpu", "gpu task aborted", "cuda", "no gpu", "queue is full"))
+
+
+def paraphrase_paragraphs(texts, temperature, progress=None, lo=0.15, hi=0.85, mode="Auto"):
+    """Returns (paragraphs, engine_note)."""
+    groups, flat = [], []
+    for text in texts:
+        sents = split_sentences(text) or [text]
+        start = len(flat)
+        flat.extend(sents)
+        groups.append((start, len(flat)))
+
+    use_gpu = not str(mode).lower().startswith("cpu")
+    fell_back = False
+    rewritten = []
+    total = max(1, len(flat))
+    step = GPU_CHUNK if use_gpu else CPU_CHUNK
+    i = 0
+    while i < len(flat):
+        chunk = flat[i:i + step]
+        engine = "GPU" if use_gpu else "CPU"
+        if progress is not None:
+            progress(lo + (hi - lo) * i / total,
+                     desc=f"Paraphrasing sentences {i + 1}–{i + len(chunk)} of {total} ({engine})")
+        if use_gpu:
+            try:
+                rewritten.extend(paraphrase_batch_gpu(chunk, temperature))
+            except Exception as err:
+                if not _is_gpu_unavailable(err):
+                    raise
+                use_gpu, fell_back, step = False, True, CPU_CHUNK
+                continue  # retry the same chunk on CPU
+        else:
+            rewritten.extend(paraphrase_batch_cpu(chunk, temperature))
+        i += len(chunk)
+
+    if fell_back:
+        note = "⚠️ GPU quota was unavailable, so the remaining text was processed on CPU (slower, same quality)."
+    elif not str(mode).lower().startswith("cpu"):
+        note = "⚡ Processed on GPU."
+    else:
+        note = "🖥️ Processed on CPU."
+    return [" ".join(rewritten[s:e]) for s, e in groups], note
+
+
+def _preview(pairs, limit=10):
+    blocks = []
+    for i, (before, after) in enumerate(pairs[:limit], 1):
+        blocks.append(
+            f"#### Change {i}\n**Original:** {before}\n\n**Paraphrased:** {after}"
+        )
+    return "\n\n---\n\n".join(blocks) if blocks else "No textual changes were generated."
+
+
+# ---------------------------------------------------------------------------
+# Handlers
+# ---------------------------------------------------------------------------
+def _docx_core(file_path, temperature, min_words, mode, progress):
+    if not file_path:
+        raise gr.Error("Please upload a .docx file.")
+    source_path = Path(file_path)
+    if source_path.suffix.lower() != ".docx":
+        raise gr.Error("Only .docx Word documents are supported.")
+
+    progress(0.05, desc="Opening Word document")
+    doc = Document(str(source_path))
+
+    targets, originals = [], []
+    for paragraph in collect_paragraphs(doc):
+        text = paragraph.text
+        if should_process(text, min_words):
+            targets.append(paragraph)
+            originals.append(text)
+
+    if not originals:
+        raise gr.Error("No eligible prose paragraphs were found in the document.")
+
+    revised, engine_note = paraphrase_paragraphs(originals, temperature, progress, mode=mode)
+
+    progress(0.9, desc="Injecting revised text into the original layout")
+    changed, pairs, final_after = 0, [], []
+    for paragraph, before, after in zip(targets, originals, revised):
+        after = (after or "").strip()
+        if after and after != before.strip():
+            replace_text_preserving_paragraph(paragraph, after)
+            changed += 1
+            pairs.append((before, after))
+            final_after.append(after)
+        else:
+            final_after.append(before)
+
+    output_path = _save_output(doc, source_path.stem)
+    progress(1.0, desc="Completed")
+
+    summary = (
+        f"✅ **Completed** — {changed} of {len(originals)} eligible paragraphs rewritten. "
+        f"Layout, styles, tables, images and headers/footers were kept in place.\n\n{engine_note}"
+    )
+    scores = score_panel("\n".join(originals), "\n".join(final_after))
+    return output_path, download_button(output_path), summary, scores, _preview(pairs)
+
+
+def _text_core(text, temperature, min_words, mode, progress):
+    text = (text or "").strip()
+    if not text:
+        raise gr.Error("Please paste some text to paraphrase.")
+    n_words = len(text.split())
+    if n_words > MAX_PASTE_WORDS:
+        raise gr.Error(
+            f"Pasted text has {n_words} words. Please keep it under {MAX_PASTE_WORDS} words, "
+            "or upload it as a .docx instead."
+        )
+
+    progress(0.05, desc="Reading pasted text")
+    paragraphs = [p.strip() for p in re.split(r"\n\s*\n|\r?\n", text)]
+    idx = [i for i, p in enumerate(paragraphs) if should_process(p, min_words)]
+    if not idx:
+        raise gr.Error(f"No paragraph has at least {int(min_words)} words of prose. Lower the minimum and try again.")
+
+    revised, engine_note = paraphrase_paragraphs([paragraphs[i] for i in idx], temperature, progress, mode=mode)
+    result = list(paragraphs)
+    pairs = []
+    for i, after in zip(idx, revised):
+        after = (after or "").strip()
+        if after and after != paragraphs[i]:
+            result[i] = after
+            pairs.append((paragraphs[i], after))
+
+    output_text = "\n\n".join(p for p in result if p)
+
+    progress(0.95, desc="Preparing download")
+    doc = Document()
+    for p in result:
+        if p:
+            doc.add_paragraph(p)
+    output_path = _save_output(doc, "pasted_text")
+    progress(1.0, desc="Completed")
+
+    summary = f"✅ **Completed** — {len(pairs)} of {len(idx)} eligible paragraphs rewritten ({n_words} words in).\n\n{engine_note}"
+    scores = score_panel(
+        "\n".join(paragraphs[i] for i in idx),
+        "\n".join(result[i] for i in idx),
+    )
+    return output_text, output_path, download_button(output_path), summary, scores
+
+
+# Single branded progress panel (replaces Gradio's per-component loaders)
+# ---------------------------------------------------------------------------
+class _Reporter:
+    def __init__(self):
+        self.frac, self.desc, self.start = 0.0, "Starting…", time.time()
+
+    def __call__(self, frac, desc=None):
+        self.frac = max(self.frac, min(1.0, float(frac)))
+        if desc:
+            self.desc = desc
+
+
+def _md2html(md):
+    html = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", md)
+    return html.replace("\n\n", "<br><br>").replace("\n", "<br>")
+
+
+def status_idle(msg):
+    return f'<div class="cs-status cs-idle">{_md2html(msg)}</div>'
+
+
+def status_done(msg):
+    return f'<div class="cs-status cs-done">{_md2html(msg)}</div>'
+
+
+def status_error(msg):
+    return f'<div class="cs-status cs-err">⚠️ {msg}</div>'
+
+
+def status_running(rep):
+    pct = round(rep.frac * 100)
+    secs = int(time.time() - rep.start)
+    return f"""
+    <div class="cs-status cs-run">
+      <div class="cs-spin-logo"></div>
+      <div class="cs-st-text">{rep.desc}</div>
+      <div class="cs-bar"><div style="width:{pct}%"></div></div>
+      <div class="cs-st-meta">{pct}% · {secs}s</div>
+    </div>"""
+
+
+def _run_live(core, args, n_outputs, status_index):
+    """Run `core` in a thread and stream only the status panel until it finishes."""
+    rep = _Reporter()
+    box = {}
+
+    def work():
+        try:
+            box["result"] = core(*args, rep)
+        except Exception as err:  # re-raised in the request thread
+            box["error"] = err
+
+    t = threading.Thread(target=work, daemon=True)
+    t.start()
+    keep = [gr.update()] * n_outputs
+    while t.is_alive():
+        frame = list(keep)
+        frame[status_index] = status_running(rep)
+        yield tuple(frame)
+        t.join(timeout=0.6)
+
+    if "error" in box:
+        err = box["error"]
+        frame = list(keep)
+        frame[status_index] = status_error(str(err) or "Something went wrong.")
+        yield tuple(frame)
+        if isinstance(err, gr.Error):
+            raise err
+        raise gr.Error(f"Processing failed: {err}")
+    yield box["result"]
+
+
+
+
+def _save_output(doc, stem, suffix="_paraphrased"):
+    """Save to a unique folder with a clean, readable file name."""
+    safe = re.sub(r"[^A-Za-z0-9_-]+", "_", stem).strip("_") or "document"
+    folder = Path(tempfile.mkdtemp(dir=OUT_DIR))
+    path = folder / f"{safe}{suffix}.docx"
+    doc.save(str(path))
+    return str(path)
+
+
+def download_button(path):
+    """Direct download link (works even if the file widget is blocked)."""
+    if not path or not Path(path).exists():
+        return ""
+    data = base64.b64encode(Path(path).read_bytes()).decode()
+    mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    name = Path(path).name
+    return (f'<a class="cs-dl" download="{name}" href="data:{mime};base64,{data}">'
+            f'⬇️ Download {name}</a>')
+
+
+def count_words(text):
+    n = len((text or "").split())
+    color = BRAND["red"] if n > MAX_PASTE_WORDS else BRAND["grey"]
+    return f"<div class='cs-count' style='color:{color}'>{n:,} / {MAX_PASTE_WORDS:,} words</div>"

packages.txt

@@ -0,0 +1,9 @@
+libreoffice-writer
+libreoffice-math
+libreoffice-calc
+libreoffice-draw
+libreoffice-impress
+fonts-liberation
+fonts-dejavu-core
+fonts-crosextra-carlito
+fonts-crosextra-caladea

requirements.txt

@@ -0,0 +1,7 @@
+torch
+transformers>=4.45,<5
+sentencepiece>=0.2
+protobuf==3.20.3
+python-docx>=1.1.2
+pymupdf
+reportlab

smart.py

@@ -0,0 +1,272 @@
+"""
+Smart Humanize = detector + humanizer working together.
+
+Loop (up to `passes` times):
+  1. score every sentence with the RoBERTa AI detector
+  2. stop if the document's AI % is at/below the target
+  3. paraphrase ONLY the sentences the detector flags (P(AI) >= moderate threshold),
+     with slightly bolder variation on each later pass
+  4. write the new sentences back in place (Word runs outside the sentence keep their formatting)
+Then score once more and report before/after.
+"""
+import re
+
+import gradio as gr
+from docx.oxml.ns import qn
+
+import detector as D
+import docx_report as DX
+import humanizer as H
+
+W_T = qn("w:t")
+_XML_SPACE = "{http://www.w3.org/XML/1998/namespace}space"
+_UNSAFE_ANCESTORS = {qn("w:fldSimple"), qn("w:hyperlink"), qn("w:ins"), qn("w:smartTag"), qn("w:sdtContent")}
+
+# citation / reference markers that must survive a rewrite
+_CITE = re.compile(r"\[\s*\d+(?:\s*[,–\-]\s*\d+)*\s*\]"
+                   r"|\((?:[A-Z][^()]{0,80}?(?:19|20)\d{2}[a-z]?(?:;\s*[^()]{0,80}?(?:19|20)\d{2}[a-z]?)*)\)")
+
+
+# ---------------------------------------------------------------- sentence rewriting
+def _guard(original, new):
+    """Reject rewrites that lose meaning-bearing content; re-attach dropped citations."""
+    new = (new or "").strip()
+    if not new:
+        return None
+    ow, nw = len(original.split()), len(new.split())
+    if nw < 0.5 * ow or nw > 1.8 * ow + 5:
+        return None
+    # numbers (results, years, units) must be kept
+    nums_o = set(re.findall(r"\d+(?:\.\d+)?%?", _CITE.sub(" ", original)))
+    nums_n = set(re.findall(r"\d+(?:\.\d+)?%?", new))
+    if not nums_o <= nums_n:
+        return None
+    missing = [c for c in _CITE.findall(original) if c not in new]
+    if missing:
+        end = re.search(r"[.!?]\s*$", new)
+        core = new[:end.start()] if end else new
+        new = core.rstrip() + " " + " ".join(missing) + (end.group(0).strip() if end else "")
+    if original[:1].isupper() and new[:1].islower():
+        new = new[0].upper() + new[1:]
+    elif original[:1].islower() and new[:1].isupper() and not new[1:2].isupper():
+        new = new[0].lower() + new[1:]                   # fragment starting mid-sentence
+    if not re.search(r"[.!?]$", original.strip()):
+        new = re.sub(r"\s*[.!?]+$", "", new)              # fragment without end punctuation
+    return new
+
+
+def _rewrite(sentences, temperature, mode, rep, lo, hi):
+    if not sentences:
+        return [], ""
+    out, note = H.paraphrase_paragraphs(sentences, temperature, rep, lo=lo, hi=hi, mode=mode)
+    return [_guard(s, n) for s, n in zip(sentences, out)], note
+
+
+# ---------------------------------------------------------------- docx: in-place span replacement
+def _run_map(p_el):
+    """[(run, start, end, safe)] over DX.para_text(p_el)."""
+    items, pos, depth = [], 0, 0
+    for r in DX.para_runs(p_el):
+        for fc in r.iter(qn("w:fldChar")):
+            t = fc.get(qn("w:fldCharType"))
+            depth += 1 if t == "begin" else -1 if t == "end" else 0
+        t = DX.run_text(r)
+        s, e = pos, pos + len(t)
+        pos = e
+        safe = DX._simple(r) and depth == 0
+        if safe:
+            a = r.getparent()
+            while a is not None and a.tag != qn("w:p"):
+                if a.tag in _UNSAFE_ANCESTORS:
+                    safe = False
+                    break
+                a = a.getparent()
+        rpr = r.find(qn("w:rPr"))
+        if safe and rpr is not None and rpr.find(qn("w:vertAlign")) is not None:
+            safe = False                                  # superscript citations, formulas
+        items.append((r, s, e, safe))
+    return items
+
+
+def replace_span(p_el, a, b, new):
+    """Replace characters [a, b) of the paragraph text. Returns False (and leaves the
+    paragraph untouched) if the span crosses fields, hyperlinks, sub/superscripts or
+    non-text runs."""
+    hit = [(r, s, e, safe) for r, s, e, safe in _run_map(p_el) if e > a and s < b and e > s]
+    if not hit or not all(x[3] for x in hit):
+        return False
+    for i, (r, s, e, _) in enumerate(hit):
+        te = r.find(W_T)
+        t = te.text or ""
+        before = t[:max(0, a - s)]
+        after = t[b - s:] if b < e else ""
+        te.text = (before + new + after) if i == 0 else after
+        te.set(_XML_SPACE, "preserve")
+        if i > 0 and not te.text and r.getparent() is not None:
+            r.getparent().remove(r)                      # drop runs emptied by the merge
+    return True
+
+
+def safe_subspan(p_el, a, b, min_words=5):
+    """Largest part of [a, b) that lies in plain text runs (so a sentence ending in a
+    superscript citation or a field can still have its prose rewritten)."""
+    runs = [(s, e, safe) for _, s, e, safe in _run_map(p_el) if e > a and s < b and e > s]
+    if runs and all(x[2] for x in runs):
+        return a, b
+    best, cur = None, None
+    for s, e, safe in runs + [(b, b, False)]:
+        if safe:
+            cur = (max(a, s) if cur is None else cur[0], min(b, e))
+        elif cur is not None:
+            if best is None or cur[1] - cur[0] > best[1] - best[0]:
+                best = cur
+            cur = None
+    if best is None:
+        return None
+    raw = DX.para_text(p_el)
+    x, y = best
+    while x < y and raw[x].isspace():
+        x += 1
+    while y > x and raw[y - 1].isspace():
+        y -= 1
+    frag = raw[x:y]
+    if len(frag.split()) < min_words or (y - x) < 0.5 * (b - a):
+        return None
+    return x, y
+
+
+# ---------------------------------------------------------------- scoring helpers
+def _score_doc(doc):
+    blocks = D.classify(D.extract_docx_live(doc))
+    if not any(b.kind == "para" for b in blocks):
+        raise gr.Error("No qualifying prose found (the detector needs paragraphs of 25+ words).")
+    D.analyse(blocks)
+    return blocks
+
+
+def _score_paras(paras):
+    blocks = D.classify([D.Block(D._norm(p)) for p in paras])
+    if not any(b.kind == "para" for b in blocks):
+        raise gr.Error("No qualifying prose found (the detector needs paragraphs of 25+ words, "
+                       "separated by a blank line).")
+    D.analyse(blocks)
+    return blocks
+
+
+def detector_pct_text(text, hi=0.80, mod=0.50):
+    try:
+        paras = [p for p in re.split(r"\n\s*\n", (text or "").replace("\r", "")) if D._norm(p)]
+        return D.summarise(_score_paras(paras), hi, mod)["pct"]
+    except Exception:
+        return None
+
+
+def detector_pct_docx(path, hi=0.80, mod=0.50):
+    try:
+        return D.summarise(_score_doc(DX.open_clean(path)), hi, mod)["pct"]
+    except Exception:
+        return None
+
+
+# ---------------------------------------------------------------- pipelines
+def _log_line(k, pct, n_flag=None, n_done=None):
+    s = f"Pass {k}: AI score {pct}%"
+    if n_flag is not None:
+        s += f" → rewrote {n_done} of {n_flag} flagged sentences"
+    return s
+
+
+def smart_docx(path, target, passes, temperature, mode, hi, mod, rep):
+    rep(0.03, "Opening Word document")
+    doc = DX.open_clean(path)
+    log, first, blocks, note, dirty = [], None, None, "", False
+    orig_text = "\n".join(b.text for b in D.classify(D.extract_docx_live(doc)) if b.kind == "para")
+    step = 0.8 / max(1, passes)
+    for k in range(1, int(passes) + 1):
+        base = 0.05 + step * (k - 1)
+        rep(base, f"Pass {k}: running AI detector")
+        blocks, dirty = _score_doc(doc), False
+        stats = D.summarise(blocks, hi, mod)
+        first = first or stats
+        if stats["pct"] <= target:
+            log.append(_log_line(k, stats["pct"]) + " — target reached")
+            break
+        jobs = []                                      # (block, span, sentence)
+        for b in blocks:
+            if b.kind != "para" or b.el is None:
+                continue
+            for sp, s, p in zip(b.cspans, b.sents, b.scores):
+                if sp and p >= mod and len(s.split()) >= 5:
+                    sub = safe_subspan(b.el, *sp)
+                    if sub:
+                        jobs.append((b, sub, b.raw[sub[0]:sub[1]]))
+        if not jobs:
+            log.append(_log_line(k, stats["pct"]) + " — no rewritable sentences left")
+            break
+        temp = min(1.5, float(temperature) + 0.15 * (k - 1))
+        new, note = _rewrite([j[2] for j in jobs], temp, mode, rep, base + 0.1 * step, base + 0.9 * step)
+        done = 0
+        # right-to-left inside each paragraph so earlier offsets stay valid
+        for (b, (a, e), _), n in sorted(zip(jobs, new), key=lambda x: (id(x[0][0]), -x[0][1][0])):
+            if n and n != b.raw[a:e] and replace_span(b.el, a, e, n):
+                done += 1
+        dirty = done > 0
+        log.append(_log_line(k, stats["pct"], len(jobs), done))
+        if not done:
+            break
+    rep(0.88, "Final AI check")
+    if dirty:
+        blocks = _score_doc(doc)
+    after = D.summarise(blocks, hi, mod)
+    new_text = "\n".join(b.text for b in blocks if b.kind == "para")
+    out = H._save_output(doc, re.sub(r"\.docx$", "", path.split("/")[-1], flags=re.I), "_humanized")
+    rep(0.95, "Preparing results")
+    return dict(before=first, after=after, log=log, note=note, blocks=blocks, path=out,
+                orig=orig_text, new=new_text)
+
+
+def smart_text(text, target, passes, temperature, mode, hi, mod, rep):
+    rep(0.03, "Reading pasted text")
+    paras = [p for p in re.split(r"\n\s*\n", (text or "").replace("\r", "")) if D._norm(p)]
+    orig = "\n\n".join(D._norm(p) for p in paras)
+    log, first, blocks, note, dirty = [], None, None, "", False
+    step = 0.8 / max(1, passes)
+    for k in range(1, int(passes) + 1):
+        base = 0.05 + step * (k - 1)
+        rep(base, f"Pass {k}: running AI detector")
+        blocks, dirty = _score_paras(paras), False
+        stats = D.summarise(blocks, hi, mod)
+        first = first or stats
+        if stats["pct"] <= target:
+            log.append(_log_line(k, stats["pct"]) + " — target reached")
+            break
+        jobs = [(bi, si, s) for bi, b in enumerate(blocks) if b.kind == "para"
+                for si, (s, p) in enumerate(zip(b.sents, b.scores)) if p >= mod and len(s.split()) >= 5]
+        if not jobs:
+            log.append(_log_line(k, stats["pct"]) + " — no rewritable sentences left")
+            break
+        temp = min(1.5, float(temperature) + 0.15 * (k - 1))
+        new, note = _rewrite([j[2] for j in jobs], temp, mode, rep, base + 0.1 * step, base + 0.9 * step)
+        done = 0
+        for (bi, si, s), n in zip(jobs, new):
+            if n and n != s:
+                blocks[bi].sents[si] = n
+                done += 1
+        paras = [" ".join(b.sents) if b.kind == "para" else b.text for b in blocks]
+        dirty = done > 0
+        log.append(_log_line(k, stats["pct"], len(jobs), done))
+        if not done:
+            break
+    rep(0.88, "Final AI check")
+    if dirty:
+        blocks = _score_paras(paras)
+    after = D.summarise(blocks, hi, mod)
+    out_text = "\n\n".join(paras)
+    from docx import Document
+    d = Document()
+    for p in paras:
+        d.add_paragraph(p)
+    path = H._save_output(d, "pasted_text", "_humanized")
+    rep(0.95, "Preparing results")
+    return dict(before=first, after=after, log=log, note=note, blocks=blocks, path=path,
+                orig=orig, new=out_text, text=out_text)