Upload 3 files

groqai.py

@@ -12,6 +12,8 @@ If Groq is unreachable or out of quota, the local checks alone are used (as befo
 
 Settings (Space → Settings → Variables and secrets):
   GROQ_API_KEY    secret — from https://console.groq.com/keys
+  GROQ_API_KEY_2, GROQ_API_KEY_3 ... (up to _9) or GROQ_API_KEYS="k1,k2,k3": more keys. Requests are spread over
+                  all keys (round robin); a key that hits its rate limit is paused and the next key is used.
   GROQ_MODELS     preference list, first one available on your key is used
                   (default: openai/gpt-oss-120b, llama-3.3-70b-versatile, qwen/qwen3.8-27b, openai/gpt-oss-20b)
   GROQ_BATCH      sentence pairs per request (default 10)
@@ -25,8 +27,19 @@ import time
 
 import textparse as TP
 
-KEY = os.getenv("GROQ_API_KEY", "").strip()
-ENABLED = bool(KEY) and os.getenv("GROQ_ENABLED", "1") != "0"
+def _read_keys():
+    """GROQ_API_KEY, GROQ_API_KEY_2 ... GROQ_API_KEY_9 and/or GROQ_API_KEYS (comma separated), de-duplicated."""
+    keys = [k.strip() for k in os.getenv("GROQ_API_KEYS", "").split(",")]
+    keys += [os.getenv("GROQ_API_KEY", "")] + [os.getenv(f"GROQ_API_KEY_{i}", "") for i in range(2, 10)]
+    return list(dict.fromkeys(k.strip() for k in keys if k and k.strip()))
+
+
+KEYS = _read_keys()
+KEY = KEYS[0] if KEYS else ""
+ENABLED = bool(KEYS) and os.getenv("GROQ_ENABLED", "1") != "0"
+# per key: paused until (rate limit / daily quota / rejected key), requests sent, last error
+_KEY_STATE = [{"until": 0.0, "calls": 0, "err": ""} for _ in KEYS]
+_rr = [0]                                         # round-robin position
 URL = "https://api.groq.com/openai/v1"
 PREF = [m.strip() for m in os.getenv(
     "GROQ_MODELS", "openai/gpt-oss-120b,llama-3.3-70b-versatile,qwen/qwen3.8-27b,openai/gpt-oss-20b").split(",")
@@ -34,7 +47,7 @@ PREF = [m.strip() for m in os.getenv(
 BATCH = max(1, int(os.getenv("GROQ_BATCH", "12")))
 MAX_WAIT = float(os.getenv("GROQ_MAX_WAIT", "60"))
 
-_lock = threading.Lock()
+_lock = threading.RLock()
 _models = None                 # models available on this key (ordered by preference)
 _down_until = 0.0              # daily quota exhausted -> skip Groq until then
 STATS = {"calls": 0, "checked": 0, "ok": 0, "fixed": 0, "rejected": 0, "errors": 0, "tokens": 0,
@@ -45,12 +58,37 @@ class Unavailable(Exception):
     """Groq cannot be used right now (quota, network, bad key) — caller falls back to the local model."""
 
 
-def _headers():
-    return {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"}
+def _headers(k=0):
+    return {"Authorization": f"Bearer {KEYS[k] if KEYS else ''}", "Content-Type": "application/json"}
+
+
+def _pick_key():
+    """Next usable key (round robin, so the load is spread over all keys); None if all are paused."""
+    now = time.time()
+    with _lock:
+        n = len(KEYS)
+        for step in range(n):
+            k = (_rr[0] + step) % n
+            if _KEY_STATE[k]["until"] <= now:
+                _rr[0] = (k + 1) % n
+                return k
+    return None
+
+
+def _pause_key(k, seconds, why):
+    with _lock:
+        _KEY_STATE[k]["until"] = max(_KEY_STATE[k]["until"], time.time() + seconds)
+        _KEY_STATE[k]["err"] = why
+
+
+def _next_free_in():
+    """Seconds until the first paused key is usable again."""
+    now = time.time()
+    return max(0.0, min((st["until"] for st in _KEY_STATE), default=0.0) - now)
 
 
 def available():
-    return ENABLED and time.time() >= _down_until
+    return ENABLED and time.time() >= _down_until and _next_free_in() <= MAX_WAIT
 
 
 def _model_list():
@@ -59,7 +97,7 @@ def _model_list():
         if _models is None:
             import httpx
             try:
-                r = httpx.get(URL + "/models", headers=_headers(), timeout=20)
+                r = httpx.get(URL + "/models", headers=_headers(_pick_key() or 0), timeout=20)
                 if r.status_code == 401:
                     STATS["last_error"] = "Groq key rejected (401) — check GROQ_API_KEY."
                     raise Unavailable(STATS["last_error"])
@@ -81,7 +119,7 @@ def _drop_model(model):
 
 
 def status():
-    if not KEY:
+    if not KEYS:
         return "Groq check is OFF — add the GROQ_API_KEY secret (Parrot output is checked by the local rules only)."
     if not ENABLED:
         return "Groq is disabled (GROQ_ENABLED=0)."
@@ -89,14 +127,20 @@ def status():
     m = (_models or PREF)[0]
     down = f" · quota pause until {time.strftime('%H:%M UTC', time.gmtime(_down_until))}" \
         if time.time() < _down_until else ""
-    return (f"Groq quality check is ON ({m}){down}. Since restart: {s['checked']} Parrot sentences checked — "
+    now = time.time()
+    keys = " · ".join(f"key {i + 1}: {st['calls']} calls" + (f", paused {int(st['until'] - now)}s ({st['err']})"
+                                                             if st["until"] > now else "")
+                      for i, st in enumerate(_KEY_STATE))
+    return (f"Groq quality check is ON ({m}), {len(KEYS)} key(s) [{keys}]{down}. Since restart: {s['checked']} Parrot sentences checked �� "
             f"{s['ok']} fine as written, {s['fixed']} repaired, {s['rejected']} rejected (original kept); "
             f"~{s['tokens']:,} tokens."
             + (f" Last error: {s['last_error']}" if s["last_error"] else ""))
 
 
 def _chat(messages, temperature, max_tokens):
-    """One chat completion (JSON mode). Waits on short rate limits, raises Unavailable on long ones."""
+    """One chat completion (JSON mode). With several keys, a rate-limited key is paused and the request moves to
+    the next key at once; it waits only when every key is paused (short limits), and raises Unavailable when all
+    keys are out for longer than GROQ_MAX_WAIT."""
     global _down_until
     import httpx
     if not available():
@@ -108,9 +152,18 @@ def _chat(messages, temperature, max_tokens):
             "response_format": {"type": "json_object"}}
     if "gpt-oss" in model:
         body["reasoning_effort"] = "low"
-    for attempt in range(8):
+    for attempt in range(8 + 2 * len(KEYS)):
+        k = _pick_key()
+        if k is None:                                  # every key is paused: wait for the first one, if short
+            wait = _next_free_in()
+            if wait > MAX_WAIT or waited + wait > MAX_WAIT:
+                STATS["last_error"] = "rate limit on all Groq keys"
+                raise Unavailable("Groq rate limit (all keys)")
+            time.sleep(wait + 0.2)
+            waited += wait
+            continue
         try:
-            r = httpx.post(URL + "/chat/completions", json=body, headers=_headers(), timeout=120)
+            r = httpx.post(URL + "/chat/completions", json=body, headers=_headers(k), timeout=120)
         except Exception as err:
             STATS["errors"] += 1
             STATS["last_error"] = f"network: {err}"
@@ -118,26 +171,27 @@ def _chat(messages, temperature, max_tokens):
                 raise Unavailable(str(err))
             time.sleep(2 * (attempt + 1))
             continue
+        with _lock:
+            _KEY_STATE[k]["calls"] += 1
         txt = r.text[:400]
         if r.status_code == 429:
             try:
                 ra = float(r.headers.get("retry-after") or 5)
             except ValueError:
                 ra = 5.0
-            if "per day" in txt.lower() or ra > MAX_WAIT or waited + ra > MAX_WAIT:
-                if "per day" in txt.lower() or ra > MAX_WAIT:
-                    _down_until = time.time() + min(max(ra, 60), 6 * 3600)
-                STATS["last_error"] = f"rate limit: {txt[:160]}"
-                raise Unavailable("Groq rate limit")
-            time.sleep(ra)
-            waited += ra
-            continue
+            daily = "per day" in txt.lower()
+            _pause_key(k, min(max(ra, 60), 6 * 3600) if daily else ra, "daily quota" if daily else "rate limit")
+            STATS["last_error"] = f"rate limit (key {k + 1}): {txt[:160]}"
+            continue                                   # next key at once
         if r.status_code == 401:
-            STATS["last_error"] = "Groq key rejected (401) — check GROQ_API_KEY."
-            _down_until = time.time() + 600
-            raise Unavailable(STATS["last_error"])
+            _pause_key(k, 3600, "key rejected (401)")
+            STATS["last_error"] = f"Groq key {k + 1} rejected (401) — check that secret."
+            if all(st["err"].startswith("key rejected") for st in _KEY_STATE):
+                _down_until = time.time() + 600
+                raise Unavailable(STATS["last_error"])
+            continue
         if r.status_code in (400, 404) and "model" in txt.lower() and any(
-                k in txt.lower() for k in ("decommission", "not found", "does not exist", "not available",
+                w in txt.lower() for w in ("decommission", "not found", "does not exist", "not available",
                                             "no access", "deprecated")):
             _drop_model(model)
             nxt = _model_list()[0]
@@ -240,7 +294,7 @@ def _check_batch(pairs, glossary):
     return _parse(content, len(pairs))
 
 
-PARALLEL = max(1, int(os.getenv("GROQ_PARALLEL", "5")))
+PARALLEL = max(1, int(os.getenv("GROQ_PARALLEL", str(min(12, 4 * max(1, len(KEYS)))))))
 
 
 def review(pairs, glossary, progress=None, lo=0.85, hi=0.9):

humanizer.py

@@ -509,6 +509,7 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
     todo = list(range(len(sent_map)))
     options, first_raw = [[] for _ in sent_map], [s for s, _, _ in sent_map]
     extra_rounds = meaning_dropped = 0
+    qstat = dict(n=0, meaning=0, fluency=0, second=0, sims=[])
     for r in range(rounds):
         if not todo:
             break
@@ -520,17 +521,30 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
         extra_rounds += r > 0
         for si in todo:
             options[si], first_raw[si] = build(si)
-        # meaning check: drop versions whose meaning drifted from the original sentence
+        # quality checks of every version: meaning (vs the original sentence) and fluency (well-formed English)
         pairs = [(si, o) for si in todo for o in options[si]]
-        keep = MEANING.keeps_meaning([(sent_map[si][0], o) for si, o in pairs])
-        drift = {(si, o) for (si, o), k in zip(pairs, keep) if not k}
-        # fluency check: drop versions with missing / doubled words or broken structure
-        ok_fl = FL.acceptable([(sent_map[si][0], o) for si, o in pairs])
-        drift |= {(si, o) for (si, o), k in zip(pairs, ok_fl) if not k}
-        if drift:
-            meaning_dropped += len(drift)
+        if pairs:
+            sims = MEANING.similarities([(sent_map[si][0], o) for si, o in pairs])
+            flu = FL.acceptable([(sent_map[si][0], o) for si, o in pairs])
+            keep_ = {}
+            for (si, o), sm, fl in zip(pairs, sims, flu):
+                keep_[(si, o)] = (sm >= MEANING.MIN_SIM and fl, sm, fl)
+                qstat["n"] += 1
+                qstat["meaning"] += sm < MEANING.MIN_SIM
+                qstat["fluency"] += not fl
+                qstat["sims"].append(sm)
             for si in todo:
-                options[si] = [o for o in options[si] if (si, o) not in drift]
+                good = [o for o in options[si] if keep_[(si, o)][0]]
+                if not good and options[si]:
+                    # second chance: no version passed both checks -> keep the closest-meaning version that is
+                    # fluent English and only slightly below the meaning threshold
+                    soft = [(keep_[(si, o)][1], o) for o in options[si]
+                            if keep_[(si, o)][2] and keep_[(si, o)][1] >= MEANING.SOFT_SIM]
+                    if soft:
+                        good = [max(soft)[1]]
+                        qstat["second"] += 1
+                meaning_dropped += len(options[si]) - len(good)
+                options[si] = good
         if not target:
             break
         todo = [si for si in todo
@@ -638,12 +652,18 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
 
     # final meaning check of what will actually be used (Groq rescues / repairs included)
     final = [si for si in range(len(sent_map)) if chosen[si] and chosen[si].strip() != sent_map[si][0].strip()]
-    for si, k_ in zip(final, MEANING.keeps_meaning([(sent_map[si][0], chosen[si]) for si in final])):
+    for si, k_ in zip(final, MEANING.keeps_meaning([(sent_map[si][0], chosen[si]) for si in final],
+                                                   min_sim=MEANING.SOFT_SIM)):
         if not k_:
             meaning_dropped += 1
             chosen[si] = next((o for o in ranked[si] if o != chosen[si]), None)   # already meaning-checked
-    if meaning_dropped:
-        print(f"[humanizer] meaning check rejected {meaning_dropped} version(s)", flush=True)
+    if qstat["n"]:
+        import statistics as _st
+        med = _st.median(qstat["sims"]) if qstat["sims"] else 0
+        print(f"[humanizer] quality checks: {qstat['n']} versions | below meaning {MEANING.MIN_SIM:.2f}: "
+              f"{qstat['meaning']} (median similarity {med:.2f}) | not fluent: {qstat['fluency']} | "
+              f"rejected in total: {meaning_dropped} | sentences saved by second chance: {qstat['second']}",
+              flush=True)
 
     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())

meaning.py

@@ -12,6 +12,8 @@ message is printed once, so the app keeps working.
 Space variables:
   MEANING_MODEL   default sentence-transformers/all-MiniLM-L6-v2
   MEANING_MIN     default 0.80  (raise to be stricter, lower if too many good rewrites are rejected)
+  MEANING_SOFT    default 0.72  a sentence with no version above MEANING_MIN may keep its closest fluent version
+                                if it reaches this similarity
   MEANING_CHECK   default 1     (0 turns the check off)
 """
 import os
@@ -19,6 +21,7 @@ import threading
 
 MODEL_ID = os.environ.get("MEANING_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
 MIN_SIM = float(os.environ.get("MEANING_MIN", "0.80"))
+SOFT_SIM = float(os.environ.get("MEANING_SOFT", "0.72"))   # second chance when no version reaches MIN_SIM
 ENABLED = os.environ.get("MEANING_CHECK", "1") != "0"
 BATCH = 64