Update app.py

app.py

@@ -1,9 +1,24 @@
 """
 Spelling Practice – Hugging Face Space
-Multi-user safe: session state is stored as a JSON string in gr.State,
-which gradio 4.40 / gradio_client 0.8 can safely introspect.
 """
 
+# ── Monkey-patch gradio_client 0.8 bug: `"const" in <bool>` crash ────────────
+# gradio_client 0.8 (shipped with gradio 4.40) has a bug in get_type() where
+# it does `if "const" in schema` but schema can be a bool (from
+# additionalProperties:true in gr.File's JSON schema).  Patch it before
+# anything imports gradio.
+try:
+    import gradio_client.utils as _gcu
+    _orig_get_type = _gcu.get_type  # type: ignore[attr-defined]
+    def _safe_get_type(schema):
+        if not isinstance(schema, dict):
+            return "Any"
+        return _orig_get_type(schema)
+    _gcu.get_type = _safe_get_type  # type: ignore[attr-defined]
+except Exception:
+    pass
+# ─────────────────────────────────────────────────────────────────────────────
+
 import os
 import glob
 import random
@@ -23,7 +38,6 @@ try:
 except ImportError:
     _LLAMA_AVAILABLE = False
 
-# ── Shared model (loaded once, read-only during inference) ─────────────────────
 _llm = None
 _llm_lock = threading.Lock()
 
@@ -42,13 +56,8 @@ def get_llm():
             return None
         model_path = gguf_files[0]
         print(f"[spelling-app] Loading model: {model_path}")
-        _llm = Llama(
-            model_path=model_path,
-            n_ctx=512,
-            n_threads=2,
-            n_gpu_layers=int(os.getenv("N_GPU_LAYERS", "-1")),
-            verbose=False,
-        )
+        _llm = Llama(model_path=model_path, n_ctx=512, n_threads=2,
+                     n_gpu_layers=int(os.getenv("N_GPU_LAYERS", "-1")), verbose=False)
         print("[spelling-app] Model ready.")
         return _llm
 
@@ -108,31 +117,20 @@ LEVELS       = ["easy", "medium", "hard", "expert"]
 LEVEL_LABELS = ["🟢 Beginner", "🔵 Intermediate", "🟠 Advanced", "🔴 Expert"]
 PASS_REQ     = 3
 
-
-# ── State helpers (serialised as JSON string to avoid gradio_client schema bug) ─
+# ── State (JSON string – safe for gradio_client 0.8 schema introspection) ─────
 
 def fresh_state_str():
-    return json.dumps({
-        "level":    0,
-        "streak":   0,
-        "sentence": "",
-        "score":    0,
-        "total":    0,
-        "history":  [],
-    })
+    return json.dumps({"level": 0, "streak": 0, "sentence": "",
+                       "score": 0, "total": 0, "history": []})
 
-def load(s):
-    return json.loads(s)
+def S(s): return json.loads(s)   # decode
+def D(d): return json.dumps(d)   # encode
 
-def dump(d):
-    return json.dumps(d)
-
-
-# ── Core helpers ───────────────────────────────────────────────────────────────
+# ── Helpers ────────────────────────────────────────────────────────────────────
 
 def _make_audio(text):
     try:
-        tts  = gTTS(text=text, lang="en", slow=True)
+        tts = gTTS(text=text, lang="en", slow=True)
         path = tempfile.mktemp(suffix=".mp3")
         tts.save(path)
         return path
@@ -140,184 +138,126 @@ def _make_audio(text):
         print(f"[spelling-app] gTTS error: {exc}")
         return None
 
-
 def _find_errors(correct, attempt):
     c_words = correct.rstrip(".").lower().split()
     a_words = attempt.rstrip(".").lower().split()
     errors  = []
-    matcher = difflib.SequenceMatcher(None, a_words, c_words)
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+    for tag, i1, i2, j1, j2 in difflib.SequenceMatcher(None, a_words, c_words).get_opcodes():
         if tag == "replace":
             for w, r in zip(a_words[i1:i2], c_words[j1:j2]):
-                if w != r:
-                    errors.append((w, r))
+                if w != r: errors.append((w, r))
         elif tag == "delete":
-            for w in a_words[i1:i2]:
-                errors.append((w, "[extra word]"))
+            for w in a_words[i1:i2]: errors.append((w, "[extra word]"))
         elif tag == "insert":
-            for r in c_words[j1:j2]:
-                errors.append(("[missing]", r))
+            for r in c_words[j1:j2]: errors.append(("[missing]", r))
     return errors
 
-
 def _ask_gemma(correct, attempt, errors):
     llm = get_llm()
-    if not llm or not errors:
-        return ""
-    error_list = "\n".join(
-        f'- You wrote "{w}", correct is "{r}"' for w, r in errors
-    )
-    prompt = (
-        "You are a friendly English spelling teacher.\n"
-        f"The student had to write: {correct}\n"
-        f"The student wrote:        {attempt}\n"
-        f"Spelling mistakes:\n{error_list}\n\n"
-        "For each mistake, write one short sentence explaining the error "
-        "and one memory tip. Be encouraging. Keep it brief."
-    )
+    if not llm or not errors: return ""
+    error_list = "\n".join(f'- You wrote "{w}", correct is "{r}"' for w, r in errors)
+    prompt = (f"You are a friendly English spelling teacher.\n"
+              f"The student had to write: {correct}\n"
+              f"The student wrote:        {attempt}\n"
+              f"Spelling mistakes:\n{error_list}\n\n"
+              "For each mistake, write one short sentence explaining the error "
+              "and one memory tip. Be encouraging. Keep it brief.")
     out = llm(prompt, max_tokens=200, temperature=0.3, stop=["###"])
     return out["choices"][0]["text"].strip()
 
-
 def _build_diff(correct, attempt):
-    c_words = correct.split()
-    a_words = attempt.split()
-    parts   = []
+    c_words, a_words = correct.split(), attempt.split()
+    parts = []
     sm = difflib.SequenceMatcher(
         None,
         [w.rstrip(".,").lower() for w in a_words],
-        [w.rstrip(".,").lower() for w in c_words],
-    )
+        [w.rstrip(".,").lower() for w in c_words])
     for tag, i1, i2, j1, j2 in sm.get_opcodes():
-        if tag == "equal":
-            parts.append(" ".join(a_words[i1:i2]))
-        elif tag == "replace":
-            parts.append(
-                "~~" + " ".join(a_words[i1:i2])
-                + "~~ **" + " ".join(c_words[j1:j2]) + "**"
-            )
-        elif tag == "delete":
-            parts.append("~~" + " ".join(a_words[i1:i2]) + "~~")
-        elif tag == "insert":
-            parts.append("**[" + " ".join(c_words[j1:j2]) + "]**")
+        if tag == "equal":   parts.append(" ".join(a_words[i1:i2]))
+        elif tag == "replace": parts.append("~~"+" ".join(a_words[i1:i2])+"~~ **"+" ".join(c_words[j1:j2])+"**")
+        elif tag == "delete":  parts.append("~~"+" ".join(a_words[i1:i2])+"~~")
+        elif tag == "insert":  parts.append("**["+" ".join(c_words[j1:j2])+"]**")
     return " ".join(parts)
 
-
 def _level_info(state):
-    lvl   = state["level"]
-    label = LEVEL_LABELS[lvl]
-    extra = (
-        f"  ·  streak {state['streak']}/{PASS_REQ} to level up"
-        if lvl < len(LEVELS) - 1
-        else "  ·  MAX LEVEL 🏆"
-    )
-    return f"**{label}**{extra}"
-
+    lvl = state["level"]
+    extra = f"  ·  streak {state['streak']}/{PASS_REQ} to level up" if lvl < len(LEVELS)-1 else "  ·  MAX LEVEL 🏆"
+    return f"**{LEVEL_LABELS[lvl]}**{extra}"
 
 def _score_info(state):
-    t   = state["total"]
-    s   = state["score"]
-    pct = int(s / t * 100) if t else 0
-    return f"**Score: {s}/{t}** ({pct}%)"
+    t, s = state["total"], state["score"]
+    return f"**Score: {s}/{t}** ({int(s/t*100) if t else 0}%)"
 
+# ── Event handlers ─────────────────────────────────────────────────────────────
 
-# ── Event handlers (state_str in, state_str out) ───────────────────────────────
-
-def new_sentence(state_str):
-    state = load(state_str)
+def new_sentence(ss):
+    state = S(ss)
     sent  = random.choice(SENTENCES[LEVELS[state["level"]]])
     state["sentence"] = sent
     audio = _make_audio(sent)
     hint  = "🎧 Listen carefully, then type what you heard and press **Submit**."
     if audio is None:
-        hint = f"⚠️ Audio unavailable. Sentence: **{sent}**  *(type it below)*"
-    return audio, "", hint, _level_info(state), _score_info(state), dump(state)
-
+        hint = f"⚠️ Audio unavailable. Sentence: **{sent}**"
+    return audio, "", hint, _level_info(state), _score_info(state), D(state)
 
-def submit_answer(attempt, state_str):
-    state = load(state_str)
+def submit_answer(attempt, ss):
+    state = S(ss)
     if not state.get("sentence"):
-        return "", "⚠️ Press **New Sentence** first!", _level_info(state), _score_info(state), dump(state)
-
+        return "", "⚠️ Press **New Sentence** first!", _level_info(state), _score_info(state), ss
     correct = state["sentence"]
     state["total"] += 1
     errors  = _find_errors(correct, attempt)
     clean_a = attempt.strip().rstrip(".").lower()
     clean_c = correct.strip().rstrip(".").lower()
-
     if not errors and clean_a == clean_c:
         state["score"]  += 1
         state["streak"] += 1
         msg = "✅ **Correct!** Every word spelled perfectly."
-        if state["streak"] >= PASS_REQ and state["level"] < len(LEVELS) - 1:
+        if state["streak"] >= PASS_REQ and state["level"] < len(LEVELS)-1:
             state["level"]  += 1
             state["streak"]  = 0
-            new_label = LEVEL_LABELS[state["level"]]
-            msg += f"\n\n🎉 **Level up! You are now {new_label}.**"
+            msg += f"\n\n🎉 **Level up! You are now {LEVEL_LABELS[state['level']]}.**"
     else:
         state["streak"] = 0
         diff_str  = _build_diff(correct, attempt)
         gemma_tip = _ask_gemma(correct, attempt, errors)
         ai_block  = f"\n\n---\n\n**💡 Tips:**\n\n{gemma_tip}" if gemma_tip else ""
-        msg = (
-            "❌ **Your answer with corrections:**\n\n"
-            + diff_str
-            + "\n\n*(~~strikethrough~~ = your error · **bold** = correct spelling)*"
-            + ai_block
-        )
-
-    state["history"].append({
-        "correct": correct,
-        "attempt": attempt,
-        "ok": not bool(errors) and clean_a == clean_c,
-        "level": LEVELS[state["level"]],
-        "ts": time.strftime("%H:%M:%S"),
-    })
+        msg = ("❌ **Your answer with corrections:**\n\n" + diff_str +
+               "\n\n*(~~strikethrough~~ = your error · **bold** = correct spelling)*" + ai_block)
+    state["history"].append({"correct": correct, "attempt": attempt,
+                              "ok": not bool(errors) and clean_a == clean_c,
+                              "level": LEVELS[state["level"]], "ts": time.strftime("%H:%M:%S")})
     state["sentence"] = ""
-    return attempt, msg, _level_info(state), _score_info(state), dump(state)
-
-
-def replay_audio(state_str):
-    state = load(state_str)
-    if state.get("sentence"):
-        return _make_audio(state["sentence"])
-    return None
+    return attempt, msg, _level_info(state), _score_info(state), D(state)
 
+def replay_audio(ss):
+    state = S(ss)
+    return _make_audio(state["sentence"]) if state.get("sentence") else None
 
-def reset_game(state_str):
-    state = load(fresh_state_str())
+def reset_game(_ss):
+    state = S(fresh_state_str())
     return None, "", "Game reset. Press **New Sentence** to start!", _level_info(state), _score_info(state), fresh_state_str()
 
-
-def export_history(state_str):
-    state   = load(state_str)
-    history = state.get("history", [])
+def export_history(ss):
+    history = S(ss).get("history", [])
     if not history:
-        return None
-    path = tempfile.mktemp(suffix=".json")
-    with open(path, "w") as f:
-        json.dump(history, f, indent=2, ensure_ascii=False)
-    return path
-
+        return "No history yet."
+    lines = ["Correct | Your answer | Level | Time | Result"]
+    for h in history:
+        ok = "✅" if h["ok"] else "❌"
+        lines.append(f'{ok} [{h["level"]}] {h["ts"]}  |  {h["correct"]}  →  {h["attempt"]}')
+    return "\n".join(lines)
 
 # ── UI ─────────────────────────────────────────────────────────────────────────
 
-CSS = """
-body { font-family: 'Segoe UI', sans-serif; }
-footer { display: none !important; }
-"""
-
-_init = load(fresh_state_str())
+CSS = "footer { display: none !important; }"
+_init = S(fresh_state_str())
 
 with gr.Blocks(title="Spelling Practice", css=CSS) as demo:
 
-    # gr.State holds a plain string – safe for gradio 4.40 / gradio_client 0.8
-    session = gr.State(fresh_state_str())
+    session = gr.State(fresh_state_str())   # plain str – no schema crash
 
-    gr.Markdown(
-        "# 📝 Spelling Practice\n"
-        "Listen to the sentence · Type it · See errors highlighted · Get AI tips"
-    )
+    gr.Markdown("# 📝 Spelling Practice\nListen · Type · See errors · Get tips")
 
     with gr.Row():
         level_md = gr.Markdown(_level_info(_init))
@@ -330,17 +270,14 @@ with gr.Blocks(title="Spelling Practice", css=CSS) as demo:
 
     audio_out  = gr.Audio(label="Listen to the sentence", autoplay=True, interactive=False)
     hint_md    = gr.Markdown("Press **New Sentence** to begin.")
-    answer_box = gr.Textbox(
-        label="Type the sentence you heard",
-        placeholder="Write the full sentence here…",
-        lines=2,
-    )
+    answer_box = gr.Textbox(label="Type the sentence you heard",
+                            placeholder="Write the full sentence here…", lines=2)
     submit_btn = gr.Button("✅ Submit", variant="primary")
     feedback   = gr.Markdown("")
 
     with gr.Accordion("📊 Session History", open=False):
-        export_btn   = gr.Button("⬇️ Export history (JSON)")
-        history_file = gr.File(label="Download", visible=True)
+        export_btn  = gr.Button("📋 Show history")
+        history_box = gr.Textbox(label="Your session", lines=10, interactive=False)
 
     OUTS = [audio_out, answer_box, hint_md, level_md, score_md, session]
 
@@ -349,7 +286,8 @@ with gr.Blocks(title="Spelling Practice", css=CSS) as demo:
     submit_btn.click(submit_answer, [answer_box, session], [answer_box, feedback, level_md, score_md, session])
     answer_box.submit(submit_answer,[answer_box, session], [answer_box, feedback, level_md, score_md, session])
     reset_btn.click(reset_game,     [session],             OUTS)
-    export_btn.click(export_history,[session],             [history_file])
+    export_btn.click(export_history,[session],             [history_box])
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)
+