Upload app.py

app.py

@@ -28,6 +28,7 @@ import time
 import site_pages as SP
 import report_flags as RF
 import lt_grammar as LT
+import textparse as TP
 
 LT.warmup()                    # start LanguageTool in the background (free grammar check)
 from humanizer import BRAND, RAINBOW, LOGO_SRC, FAVICON_SRC, FAVICON_PATH, MODES, OUT_DIR
@@ -45,17 +46,20 @@ def _stats_gauge(title, pct, caption, good_low=True):
     return H._gauge(title, pct, caption, invert=not good_low)
 
 
-def suite_panel(ai_before, ai_after, original, revised, labels=None):
-    sim = H.similarity_to_source(original, revised)
-    changed = H.words_changed(original, revised)
-    lb = labels or ("AI score · before", "RoBERTa detector on your original",
-                    "AI score · after", "RoBERTa detector on the rewritten text")
+def suite_panel(ai_before, ai_after, original, revised, labels=None, extra=None, sim_vocab=True):
+    lb = labels or ("AI · our detector, before", "Open-source detector on your original",
+                    "AI · our detector, after", "Same detector on the rewritten text")
+    gauges = [_stats_gauge(lb[0], ai_before, lb[1]), _stats_gauge(lb[2], ai_after, lb[3])]
+    gauges += [_stats_gauge(t, v, c) for t, v, c in (extra or [])]
+    if sim_vocab:
+        sim = H.similarity_to_source(original, revised)
+        changed = H.words_changed(original, revised)
+        gauges += [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"])]
+    cols = min(4, max(2, len(gauges)))
     return f"""
-    <div class="cs-scores">
-      {_stats_gauge(lb[0], ai_before, lb[1])}
-      {_stats_gauge(lb[2], ai_after, lb[3])}
-      {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 class="cs-scores" style="grid-template-columns:repeat({cols},1fr)">
+      {"".join(gauges)}
     </div>
     <div class="cs-disclaimer">
       <b>Indicators only.</b> The AI score comes from an open-source detector and will differ from Turnitin,
@@ -297,12 +301,16 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
     gline = _grammar_line(res.get("note"))
     rs = res.get("report")
     table = ""
+    extra = None
     if rs:                                             # report-guided run
         what = "AI" if rs.get("kind") != "Similarity" else "Similarity"
         if rs.get("score") is not None:
             g_before, g_after = rs["score"], rs["est"]
-            labels = (f"{what} · {rs['tool']}", "Score read from your uploaded report",
-                      f"{what} · estimated after", f"Estimate for the same report; re-check with {rs['tool']} to confirm")
+            labels = (f"{what} · {rs['tool']} report", "Read from the report you uploaded",
+                      f"{what} · {rs['tool']}, estimated now", f"Our estimate for {rs['tool']}; re-check there to confirm")
+            if what == "AI":                           # our own detector, clearly labelled as a different scale
+                extra = [("AI · our detector, now", a["pct"],
+                          f"Open-source detector (was {b['pct']}%); a different scale from {rs['tool']}")]
             msg = (f"✅ **Done** — {rs['tool']} {what} score {rs['score']:g}% → estimated **{rs['est']:g}%** "
                    f"after rewriting. Re-check with {rs['tool']} for the actual score.")
         else:
@@ -316,7 +324,10 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
         table = _report_table(rs)
     msg += gline
     preview = D.build_html(res["blocks"], a, hi, mod)
-    panel = suite_panel(g_before, g_after, res["orig"], res["new"], labels) + table
+    panel = suite_panel(g_before, g_after, res["orig"], res["new"], labels, extra) + table
+    _remember(res["path"], ours=a["pct"], ours_before=b["pct"],
+              tool=(rs or {}).get("tool"), kind=(rs or {}).get("kind"),
+              rep_score=(rs or {}).get("score"), rep_est=(rs or {}).get("est"))
     out = [H.status_done(msg), preview, panel, res["path"], H.download_button(res["path"])]
     if text_mode:
         out.insert(1, res["text"])
@@ -324,6 +335,23 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
 
 
 REPORT_KINDS = ["AI-writing report", "Similarity / plagiarism report"]
+RESULT_CTX = {}          # sha1 of an output file -> its scores (so a later proofread can show matching indicators)
+
+
+def _file_key(path):
+    try:
+        with open(path, "rb") as fh:
+            return hashlib.sha1(fh.read()).hexdigest()
+    except Exception:
+        return None
+
+
+def _remember(path, **ctx):
+    k = _file_key(path)
+    if k:
+        if len(RESULT_CTX) > 2000:
+            RESULT_CTX.clear()
+        RESULT_CTX[k] = ctx
 
 
 def _use_report(report, kind=None, rep=None):
@@ -414,11 +442,27 @@ def smart_docx(path, target, passes, temp, mode, hi, mod, full_ai, vocab, report
 
 
 # ---------------- Rigorous proofread (of a finished humanized document) ----------------
-def _proof_core(result, original, hi, mod, rep):
+def _proof_panel(res, ctx):
+    """Indicators after a proofread, on the same scales as the result it was run on."""
+    b, a = res["before"]["pct"], res["after"]["pct"]
+    labels = ("AI · our detector, before proofread", "Open-source detector on the file you proofread",
+              "AI · our detector, after proofread", "Same detector on the proofread file")
+    extra = [("Sentences corrected", round(100 * res["n"] / max(1, res["total"])),
+              f"{res['n']} of {res['total']} sentences")]
+    if ctx and ctx.get("rep_est") is not None and ctx.get("kind") != "Similarity":
+        est = max(0, min(100, round(ctx["rep_est"] + (a - b))))
+        extra.insert(0, (f"AI · {ctx['tool']}, estimated after proofread", est,
+                         f"Was {ctx['rep_est']:g}% estimated after humanizing; re-check with {ctx['tool']}"))
+    return suite_panel(b, a, "", "", labels, extra, sim_vocab=False)
+
+
+def _proof_core(result, original, hi, mod, rep, standalone=False):
     import proofread as PR
     path = result if isinstance(result, str) else getattr(result, "name", None)
     if not path or not str(path).lower().endswith(".docx"):
-        raise gr.Error("Humanize a Word document first; the proofread works on the humanized file.")
+        raise gr.Error("Upload a Word (.docx) file to proofread." if standalone else
+                       "Humanize a Word document first; the proofread works on the humanized file.")
+    ctx = RESULT_CTX.get(_file_key(path))
     try:
         res = PR.proofread_docx(path, original if original and str(original).lower().endswith(".docx") else None,
                                 rep, hi, mod)
@@ -428,17 +472,53 @@ def _proof_core(result, original, hi, mod, rep):
         raise gr.Error(str(err))
     rep.meta.update(name=os.path.basename(str(path)), words=res["before"]["all_words"],
                     before=res["before"]["pct"], after=res["after"]["pct"], output=res["path"])
-    return (H.status_done(f"✅ **Proofread done** — {res['n']} of {res['total']} sentences corrected. "
-                          f"AI score {res['before']['pct']}% → {res['after']['pct']}%.\n\n" + res["note"]),
-            res["path"], H.download_button(res["path"]))
+    _remember(res["path"], ours=res["after"]["pct"], ours_before=res["before"]["pct"],
+              **{k: (ctx or {}).get(k) for k in ("tool", "kind", "rep_score")},
+              rep_est=(None if not ctx or ctx.get("rep_est") is None else
+                       max(0, min(100, round(ctx["rep_est"] + res["after"]["pct"] - res["before"]["pct"])))))
+    head = f"✅ **Proofread done** — {res['n']} of {res['total']} sentences corrected."
+    return (H.status_done(head + "\n\n" + res["note"]), res["path"], H.download_button(res["path"]),
+            _proof_panel(res, ctx))
 
 
 def proofread_doc(result, original, hi, mod, user, request: gr.Request = None):
     """Free follow-up step on a document the user just humanized (does not use a document from the plan)."""
-    yield from _stream(_proof_core, (result, original, hi, mod), 3, 0, user, True, request,
+    yield from _stream(_proof_core, (result, original, hi, mod), 4, 0, user, True, request,
                        tool="Proofread", quota=False)
 
 
+PROOF_STANDALONE_FREE = os.getenv("PROOF_STANDALONE_FREE", "0") == "1"
+
+
+def _proof_new_core(file, original, hi, mod, rep):
+    return _proof_core(file, original, hi, mod, rep, standalone=True)
+
+
+def proofread_new(file, original, hi, mod, user, request: gr.Request = None):
+    """Proofread any Word document (a new article): uses one document from the plan unless PROOF_STANDALONE_FREE=1."""
+    yield from _stream(_proof_new_core, (file, original, hi, mod), 4, 0, user, True, request,
+                       tool="Proofread", words=P.doc_words(file) if file else None, quota=not PROOF_STANDALONE_FREE)
+
+
+def _proof_text_core(text, hi, mod, rep):
+    from docx import Document
+    d = Document()
+    for p in [p for p, _ in TP.parse_paste(text)]:
+        d.add_paragraph(p)
+    tmp = OUT_DIR / f"paste_{secrets.token_hex(6)}.docx"
+    d.save(tmp)
+    st, path, dl, panel = _proof_core(str(tmp), None, hi, mod, rep, standalone=True)
+    out_text = "\n\n".join(p.text for p in Document(path).paragraphs if p.text.strip())
+    return st, out_text, path, dl, panel
+
+
+def proofread_text(text, hi, mod, user, request: gr.Request = None):
+    if not (text or "").strip():
+        raise gr.Error("Please paste some text to proofread.")
+    yield from _stream(_proof_text_core, (text, hi, mod), 5, 0, user, False, request, tool="Proofread",
+                       paste=text)
+
+
 # ---------------- Detector ----------------
 def _det_core(file, text, hi, mod, rep):
     if mod >= hi:
@@ -491,6 +571,7 @@ def _hum_docx_core(path, temp, min_words, mode, full_ai, vocab, rep):
     rep.meta.update(name=os.path.basename(str(path)), words=len(orig.split()), before=b, after=a, output=out,
                     engine="CPU" if "CPU" in summary else "GPU")
     panel = suite_panel(b, a, orig, new)
+    _remember(out, ours=a, ours_before=b)
     print(f"[humanizer] {summary}", flush=True)
     return out, dl, H.status_done(summary.split("\n\n")[0] + _grammar_line(summary)), panel, preview
 
@@ -1451,10 +1532,47 @@ with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CS
                                 sd_pr_status = gr.HTML()
                                 sd_pr_file = gr.File(label="Download proofread .docx", interactive=False)
                                 sd_pr_dl = gr.HTML()
+                        sd_pr_panel = gr.HTML()
                         sd_scores = gr.HTML(EMPTY)
                         with gr.Accordion("Final AI highlight view", open=False):
                             sd_prev = gr.HTML()
 
+                with gr.Tab("🔍 Proofread only"):
+                    gr.Markdown("Proofread **any** article or chapter, no humanizing needed: grammar first (every "
+                                "error fixed and verified), then clarity, academic wording and flow, doubled terms "
+                                "and AI leftovers removed, while keeping the AI score where it was.")
+                    with gr.Tabs(elem_classes="sub-tabs"):
+                        with gr.Tab("📄 Word document 🔒"):
+                            _, pn_open, pn_lockbtn = lock_gate("Word documents")
+                            GOTO_ACCOUNT.append(pn_lockbtn)
+                            with pn_open:
+                                with gr.Row(equal_height=False):
+                                    with gr.Column(elem_classes="cs-card"):
+                                        pn_in = gr.File(label="Document to proofread (.docx)", file_types=[".docx"],
+                                                        type="filepath")
+                                        pn_orig = gr.File(label="Optional: the author's original version (.docx), "
+                                                                "used to repair unclear sentences",
+                                                          file_types=[".docx"], type="filepath")
+                                        pn_btn = gr.Button("🔍 Proofread document", variant="primary", size="lg")
+                                    with gr.Column(elem_classes="cs-card"):
+                                        pn_status = gr.HTML(H.status_idle("Upload a .docx and press **Proofread "
+                                                                          "document**."))
+                                        pn_file = gr.File(label="Download proofread .docx", interactive=False)
+                                        pn_dl = gr.HTML()
+                                pn_panel = gr.HTML(EMPTY)
+                        with gr.Tab("✍️ Paste text"):
+                            with gr.Row(equal_height=False):
+                                with gr.Column(elem_classes="cs-card"):
+                                    pt_in = gr.Textbox(label="Text to proofread", lines=12,
+                                                       placeholder="Paste a paragraph, abstract or section…")
+                                    pt_btn = gr.Button("🔍 Proofread text", variant="primary", size="lg")
+                                with gr.Column(elem_classes="cs-card"):
+                                    pt_status = gr.HTML(H.status_idle("Paste text and press **Proofread text**."))
+                                    pt_out = gr.Textbox(label="Proofread text", lines=12, interactive=False)
+                                    pt_file = gr.File(label="Download as .docx", interactive=False)
+                                    pt_dl = gr.HTML()
+                            pt_panel = gr.HTML(EMPTY)
+
         # ============================ DETECTOR ============================
         with gr.Tab("🔍 AI Detector", id="detect"):
             gr.HTML('<div class="cs-intro"><b>AI Writing Report.</b> Sentence-level highlighting '
@@ -1558,6 +1676,7 @@ with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CS
                                 hd_pr_status = gr.HTML()
                                 hd_pr_file = gr.File(label="Download proofread .docx", interactive=False)
                                 hd_pr_dl = gr.HTML()
+                        hd_pr_panel = gr.HTML()
                         hd_scores = gr.HTML(EMPTY)
                         with gr.Accordion("Preview of changes (first 10)", open=False):
                             hd_prev = gr.Markdown()
@@ -1906,11 +2025,17 @@ with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CS
 
     # rigorous proofread of the humanized file
     sd_pr_btn.click(lambda: WAIT, None, sd_pr_status, queue=False, **HID).then(
-        proofread_doc, [sd_file, sd_in, s_hi, s_mod, user_state], [sd_pr_status, sd_pr_file, sd_pr_dl],
+        proofread_doc, [sd_file, sd_in, s_hi, s_mod, user_state], [sd_pr_status, sd_pr_file, sd_pr_dl, sd_pr_panel],
         **JOB(sd_pr_status))
     hd_pr_btn.click(lambda: WAIT, None, hd_pr_status, queue=False, **HID).then(
-        proofread_doc, [hd_file, hd_in, s_hi, s_mod, user_state], [hd_pr_status, hd_pr_file, hd_pr_dl],
+        proofread_doc, [hd_file, hd_in, s_hi, s_mod, user_state], [hd_pr_status, hd_pr_file, hd_pr_dl, hd_pr_panel],
         **JOB(hd_pr_status))
+    pn_btn.click(lambda: WAIT, None, pn_status, queue=False, **HID).then(
+        proofread_new, [pn_in, pn_orig, s_hi, s_mod, user_state], [pn_status, pn_file, pn_dl, pn_panel],
+        **JOB(pn_status))
+    pt_btn.click(lambda: WAIT, None, pt_status, queue=False, **HID).then(
+        proofread_text, [pt_in, s_hi, s_mod, user_state], [pt_status, pt_out, pt_file, pt_dl, pt_panel],
+        **JOB(pt_status))
 
     # detector
     dp_run = dp_btn.click(lambda: WAIT, None, dp_status, queue=False, **HID).then(detect_text, [dp_in, d_hi, d_mod, user_state], [dp_status, dp_html, dp_pdf, dp_dl], **JOB(dp_status))