Upload 3 files

README.md

@@ -178,13 +178,28 @@ in your privacy policy.
 - **Best of 3**: Parrot samples 3 paraphrases of every sentence in one pass (`HUM_CANDIDATES`, default 3); lost
   technical terms are copied back in place, broken versions are dropped, and the AI detector picks the most
   human-sounding survivor (`HUM_SELECT=0` turns the detector choice off). Groq then checks the chosen sentence.
-- **100% AI-written box**: Parrot writes 5 versions of every sentence instead of 3 (`HUM_CANDIDATES_AI`), the
+- **Single method in every mode (default `HUM_AI_METHOD=single`)**: box ticked or not, Parrot writes ONE
+  paraphrase per sentence and Groq repairs it. **Vocabulary change (%) slider**: 0 = off (one round only);
+  above 0, sentences below the level are paraphrased again, up to `HUM_SINGLE_ROUNDS` (3) extra rounds.
+  `HUM_AI_METHOD=multi` restores the saved best version (3 / 5 versions per sentence). Ticking the 100% AI box sets
+  the slider to 70; unticking sets it back to 0. In Smart Humanize (box unticked) only the sentences the
+  detector flags are rewritten, so the level applies to those sentences.
+- **100% AI-written box — single method (default, `HUM_AI_METHOD=single`)**: Parrot writes ONE paraphrase per
+  sentence and Groq repairs it against the original (terms, meaning, grammar), as before. The user picks the
+  **Vocabulary change (%)** slider (30–90, shown when the box is ticked). Sentences below that level are
+  paraphrased again — Parrot rewrites its own version, one version per round with a little more variation —
+  up to `HUM_SINGLE_ROUNDS` (3) extra rounds; the version with the most new wording is kept. Groq's repair is
+  used unless it copies most of the original back. Set `HUM_AI_METHOD=multi` to use the method below instead.
+- **100% AI-written box — multi method (`HUM_AI_METHOD=multi`, the saved best version)**: Parrot writes 5 versions of every sentence instead of 3 (`HUM_CANDIDATES_AI`), the
   plain-wording rules add more options, the detector ranks them, and Groq checks the 2 most human versions
   (`HUM_GROQ_SHORTLIST`). The most human version Groq accepts is kept; if both are rejected, the next
   version or the original sentence is used. Parrot still does all the rewriting; Groq only checks.
   It also aims for 70% new wording per sentence (`HUM_AI_CHANGE_TARGET`, same measure as the "Vocabulary
   changed" gauge): sentences below it get up to 2 extra Parrot rounds with more variation (`HUM_AI_ROUNDS`),
   versions that reach it are preferred, and Groq's check may not pull the wording back toward the original.
+  In Smart Humanize each pass already rewrites again, so the inner extra rounds drop to 1 (`SMART_AI_ROUNDS`)
+  and the separate retry is skipped in this mode. Speed settings: `HUM_GPU_BATCH` (32), `GROQ_PARALLEL` (5),
+  `GROQ_BATCH` (12).
 - Speed: sentences are batched shortest-first and generation stops just past the input length; Groq batches run
   3 at a time (`GROQ_PARALLEL`).
 

humanizer.py

@@ -384,12 +384,12 @@ CANDIDATES_AI = max(1, int(os.getenv("HUM_CANDIDATES_AI", "5")))
 GROQ_SHORTLIST = max(1, int(os.getenv("HUM_GROQ_SHORTLIST", "2")))
 # 100% AI mode: target share of new wording per sentence (same measure as the "Vocabulary changed" gauge)
 # and the number of extra Parrot rounds for sentences below it.
-AI_CHANGE_TARGET = float(os.getenv("HUM_AI_CHANGE_TARGET", "70"))
+AI_CHANGE_TARGET = float(os.getenv("HUM_AI_CHANGE_TARGET", "70"))   # used when no slider value is passed
 AI_ROUNDS = max(0, int(os.getenv("HUM_AI_ROUNDS", "2")))
 # 100% AI method: "single" = Parrot writes ONE paraphrase per sentence and Groq repairs it; sentences below the
 # user's vocabulary-change level are paraphrased again (Parrot re-writes its own version) up to SINGLE_ROUNDS
 # more times. "multi" = the saved best version (5 Parrot versions per sentence, detector picks, Groq checks top 2).
-AI_METHOD = os.getenv("HUM_AI_METHOD", "single").strip().lower()
+AI_METHOD = os.getenv("HUM_AI_METHOD", "single").strip().lower()   # applies with the box ticked AND unticked
 SINGLE_ROUNDS = max(0, int(os.getenv("HUM_SINGLE_ROUNDS", "3")))
 # Vocabulary-change level chosen by the user on the slider (per job); None -> AI_CHANGE_TARGET.
 VOCAB_TARGET = contextvars.ContextVar("vocab_target", default=None)
@@ -441,12 +441,13 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
         groups.append((g0, len(sent_map)))
 
     full_ai = FULL_AI.get()
-    if full_ai and AI_METHOD == "single":
+    if AI_METHOD == "single":                  # box ticked or not: ONE Parrot version per sentence + Groq repair
         return _paraphrase_single(texts, temperature, progress, lo, hi, mode)
     k = CANDIDATES_AI if full_ai else CANDIDATES
-    target = change_target() if full_ai else 0.0
+    # normal mode: the Vocabulary change slider (0 = off = the original behaviour)
+    target = change_target() if full_ai else float(VOCAB_TARGET.get() or 0)
     er = EXTRA_ROUNDS.get()
-    rounds = 1 + ((AI_ROUNDS if er is None else er) if full_ai else 0)
+    rounds = 1 + ((AI_ROUNDS if er is None else er) if (full_ai or target) else 0)
     temp0 = min(1.5, float(temperature) + (0.2 if full_ai else 0.0))
     p_hi = lo + (hi - lo) * (0.7 if G.available() else 0.85)   # room on the bar for scoring / Groq
     p_gen = lo + (p_hi - lo) * (0.75 if full_ai else 1.0)      # 100% AI: room for the extra rounds
@@ -620,8 +621,8 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
                 for n_, (si, ok, cand_) in enumerate(fixes):
                     if sc and sc[n_] > sc[m + n_] + 0.02:       # never trade AI score for polish
                         continue
-                    if target and change(si, ok) < min(target, change(si, cand_) - 10):
-                        continue                                 # 100% AI: Groq must not undo the rewrite
+                    if target and change(si, ok) < 0.5 * change(si, cand_):
+                        continue                                 # Groq copied most of the original back
                     chosen[si] = ok
                 note += (f" ✅ Groq checked the top {shortlist} versions of each sentence." if shortlist > 1
                          else " ✅ Academic wording checked by Groq.")
@@ -631,6 +632,12 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
 
     sentences = [chosen[si] or s for si, (s, _, _) in enumerate(sent_map)]
     changed = sum(1 for si, (s, _, _) in enumerate(sent_map) if sentences[si].strip() != s.strip())
+    if target and not full_ai:
+        hit = sum(1 for si, (s0, _, _) in enumerate(sent_map)
+                  if sentences[si].strip() != s0.strip() and change(si, sentences[si]) >= target)
+        note += (f" 🔤 Vocabulary change {target:.0f}%"
+                 + (f", {extra_rounds} extra round(s)" if extra_rounds else "")
+                 + f": {hit} of {len(sent_map)} sentences reach it.")
     if full_ai:
         hit = sum(1 for si, (s0, _, _) in enumerate(sent_map)
                   if sentences[si].strip() != s0.strip() and change(si, sentences[si]) >= target)
@@ -675,7 +682,7 @@ def _gen_flat(flat, temp, k, state, progress, a_, b_, label):
 
 
 def _paraphrase_single(texts, temperature, progress=None, lo=0.15, hi=0.85, mode="Auto"):
-    """100% AI mode, "single" method. Returns (paragraphs, engine_note).
+    """"single" method (default, box ticked or not). Returns (paragraphs, engine_note).
     1. Parrot writes ONE paraphrase of every sentence (long sentences clause by clause).
     2. Lost technical terms are copied back; versions that lose terms / numbers / citations are dropped.
     3. Sentences whose new wording is below the user's level are paraphrased again: Parrot rewrites its own
@@ -690,9 +697,11 @@ def _paraphrase_single(texts, temperature, progress=None, lo=0.15, hi=0.85, mode
         groups.append((len(sents), len(sents) + len(ss)))
         sents.extend(ss)
     n = len(sents)
-    target = change_target()
+    full_ai = FULL_AI.get()
+    # box ticked: slider level (70 unless the user changed it); unticked: slider level, 0 = off (one round only)
+    target = change_target() if full_ai else float(VOCAB_TARGET.get() or 0)
     er = EXTRA_ROUNDS.get()
-    rounds = 1 + (SINGLE_ROUNDS if er is None else er)
+    rounds = 1 + ((SINGLE_ROUNDS if er is None else er) if target else 0)
     glossary = TP.build_glossary(texts) | TP.GLOSSARY.get()
     state = {"gpu": ON_GPU and not str(mode).lower().startswith("cpu"), "fell_back": False}
     p_hi = lo + (hi - lo) * (0.7 if G.available() else 0.95)
@@ -774,9 +783,10 @@ def _paraphrase_single(texts, temperature, progress=None, lo=0.15, hi=0.85, mode
     out = [chosen[si] or sents[si] for si in range(n)]
     changed = sum(1 for si in range(n) if out[si].strip() != sents[si].strip())
     hit = sum(1 for si in range(n) if out[si].strip() != sents[si].strip() and change(si, out[si]) >= target)
-    note += (f" 🤖 100% AI mode: 1 Parrot version per sentence"
+    note += ((" 🤖 100% AI mode:" if full_ai else "") + " ✏️ 1 Parrot version per sentence"
              + (f", up to {used + 1} rounds" if used else "")
-             + f"; {hit} of {n} sentences reach {target:.0f}% new wording. ✍️ {changed} of {n} sentences rewritten.")
+             + (f"; {hit} of {n} sentences reach {target:.0f}% new wording." if target else ".")
+             + f" ✍️ {changed} of {n} sentences rewritten.")
     return [" ".join(out[a:b]) for a, b in groups], note
 
 

smart.py

@@ -155,6 +155,8 @@ def _rewrite_retry(sentences, temperature, mode, rep, lo, hi):
     """Paraphrase; sentences that come back unchanged or rejected get one bolder retry.
     100% AI mode: the humanizer already re-runs weak sentences itself (1 extra round per pass here, since
     every Smart pass rewrites again), so the separate retry is skipped — it only repeated the same work."""
+    if getattr(H, "AI_METHOD", "") == "single" and not _full_ai():
+        return _rewrite(sentences, temperature, mode, rep, lo, hi)   # one Parrot version; slider rounds only
     if _full_ai():
         tok = H.EXTRA_ROUNDS.set(int(__import__("os").getenv("SMART_AI_ROUNDS", "1")))
         try: