Update app.py

app.py

@@ -31,7 +31,7 @@ threading.Thread(target=_check_server, daemon=True).start()
 with open("lessons.json") as f:
     LESSONS = json.load(f)
 
-LISTEN_SECONDS = 10  # 15 min
+LISTEN_SECONDS = 900  # 15 min  (set to 10 for testing)
 PASS_SCORE     = 6
 
 # ── Cache audio ───────────────────────────────────────────────────────────────
@@ -146,11 +146,13 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
             "Écoutez pendant **15 minutes** complètes, puis cliquez sur **🔄 Vérifier le temps**."
         )
         return (
-            state, audio, msg,
-            gr.update(visible=True),   # listen_col
-            gr.update(visible=False),  # quiz_col
-            gr.update(visible=False),  # result_col
-            gr.update(visible=False),  # cert_col
+            state,
+            audio,
+            msg,
+            gr.update(visible=True),                              # listen_col
+            gr.update(visible=False),                             # quiz_col
+            gr.update(visible=False),                             # result_col
+            gr.update(visible=False),                             # cert_col
             gr.update(interactive=False, value="⏳ Écoute en cours…"),  # quiz_btn
         )
 
@@ -171,28 +173,61 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
             state,
         )
 
+    # ── FIX: open_quiz ─────────────────────────────────────────────────────────
+    # Previously the early-return branch had mismatched gr.update() calls,
+    # causing the quiz column to never become visible.  We now:
+    #   1. Guard against missing/empty questions list.
+    #   2. Use gr.update() (no args) for components we don't want to touch in
+    #      the early-return path instead of gr.update(value="") which can
+    #      collide with Gradio 5's diffing logic.
+    #   3. Keep listen_col visible (not hidden) in the early-return path so the
+    #      user still sees the timer message.
     def open_quiz(state):
-        elapsed = time.time() - (state["listen_start"] or 0)
+        elapsed = time.time() - (state.get("listen_start") or 0)
+
+        # ── Timer not elapsed yet ──
         if elapsed < LISTEN_SECONDS:
             m, s = divmod(int(LISTEN_SECONDS - elapsed), 60)
             return (
                 state,
-                gr.update(visible=True),  gr.update(visible=False),
-                gr.update(visible=False), gr.update(visible=False),
-                gr.update(value=f"⚠️ Patientez encore **{m} min {s:02d} s**."),
-                gr.update(value=""), gr.update(value=""),
+                gr.update(visible=True),   # listen_col  — keep showing
+                gr.update(visible=False),  # quiz_col    — stay hidden
+                gr.update(visible=False),  # result_col
+                gr.update(visible=False),  # cert_col
+                gr.update(value=f"⚠️ Patientez encore **{m} min {s:02d} s**."),  # timer_info
+                gr.update(),               # question_md — no change
+                gr.update(),               # answer_box  — no change
+            )
+
+        lesson_idx = state.get("lesson_idx", 0)
+        questions  = LESSONS[lesson_idx].get("questions", [])
+
+        # ── Guard: no questions defined for this lesson ──
+        if not questions:
+            return (
+                state,
+                gr.update(visible=True),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="⚠️ Aucune question disponible pour cette leçon."),
+                gr.update(),
+                gr.update(),
             )
-        lesson_idx    = state.get("lesson_idx", 0)
-        idx           = random.randrange(len(LESSONS[lesson_idx]["questions"]))
+
+        idx           = random.randrange(len(questions))
         state         = {**state, "phase": "quiz", "question_idx": idx}
-        question_text = LESSONS[lesson_idx]["questions"][idx]["q"]
+        question_text = questions[idx]["q"]
+
         return (
             state,
-            gr.update(visible=False), gr.update(visible=True),
-            gr.update(visible=False), gr.update(visible=False),
-            gr.update(value=""),
-            gr.update(value=question_text),
-            gr.update(value=""),
+            gr.update(visible=False),          # listen_col  — hide
+            gr.update(visible=True),           # quiz_col    — SHOW ← the key fix
+            gr.update(visible=False),          # result_col
+            gr.update(visible=False),          # cert_col
+            gr.update(value=""),               # timer_info  — clear
+            gr.update(value=question_text),    # question_md — set question
+            gr.update(value=""),               # answer_box  — clear previous answer
         )
 
     def submit_answer(answer, state):
@@ -203,12 +238,13 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
                 state,
                 gr.update(visible=True),  gr.update(visible=False),
                 gr.update(visible=False), gr.update(visible=False),
-                "", gr.update(value="📤 Soumettre", interactive=True),
+                "",
+                gr.update(value="📤 Soumettre", interactive=True),
                 gr.update(interactive=True),
             )
             return
 
-        # Step 1: disable immediately
+        # Step 1: disable buttons immediately while evaluating
         yield (
             state,
             gr.update(visible=False), gr.update(visible=True),
@@ -237,7 +273,7 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
                 f"Seuil requis : **{PASS_SCORE}/10**. Veuillez **réécouter la leçon** avant de retenter."
             )
 
-        # Step 3: show result
+        # Step 3: show result panel
         yield (
             state,
             gr.update(visible=False), gr.update(visible=False),
@@ -251,19 +287,22 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
         lesson_idx = state.get("lesson_idx", 0)
         total      = len(LESSONS)
 
+        # Failed → restart the same lesson's listening phase
         if state["phase"] == "fail":
             return start_listening(state)
 
+        # Passed last lesson → show certificate
         if lesson_idx >= total - 1:
             state = {**state, "phase": "done"}
-            cert  = (
+            # Build dynamic checklist from actual lesson titles
+            checklist = "\n\n".join(
+                f"✅ Leçon {i + 1} — {LESSONS[i]['title']}"
+                for i in range(total)
+            )
+            cert = (
                 "# 🏆 Félicitations !\n\n"
-                "Vous avez complété avec succès les **5 leçons** du cours de procédure pénale :\n\n"
-                "✅ Leçon 1 — Les principes directeurs et la preuve pénale\n\n"
-                "✅ Leçon 2 — La police judiciaire, l'enquête et la garde à vue\n\n"
-                "✅ Leçon 3 — L'action publique, l'action civile et la prescription\n\n"
-                "✅ Leçon 4 — L'instruction préparatoire et les mesures de sûreté\n\n"
-                "✅ Leçon 5 — Les juridictions de jugement et les voies de recours\n\n"
+                f"Vous avez complété avec succès les **{total} leçons** du cours :\n\n"
+                f"{checklist}\n\n"
                 "---\n\n*Ce certificat atteste de votre réussite aux évaluations.*"
             )
             return (
@@ -272,34 +311,386 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
                 gr.update(visible=False), gr.update(visible=True),
                 gr.update(interactive=False, value="✅ Terminé"),
             )
+
+        # Passed → advance to next lesson
+        state = {**state, "lesson_idx": lesson_idx + 1, "listen_start": None}
+        return start_listening(state)
+
+    def restart_from_cert(state):
+        return start_listening(fresh())
+
+    # ── Wiring ────────────────────────────────────────────────────────────────
+    # Outputs shared by start_listening / handle_next / restart_from_cert
+    LISTEN_OUT = [session, audio_out, listen_msg,
+                  listen_col, quiz_col, result_col, cert_col, quiz_btn]
+
+    start_btn.click(start_listening, inputs=[session], outputs=LISTEN_OUT)
+
+    check_btn.click(check_timer, inputs=[session], outputs=[quiz_btn, timer_info, session])
+
+    # Outputs for open_quiz — must match exactly what open_quiz() returns (8 values)
+    QUIZ_OUT = [session, listen_col, quiz_col, result_col, cert_col,
+                timer_info, question_md, answer_box]
+    quiz_btn.click(open_quiz, inputs=[session], outputs=QUIZ_OUT)
+
+    # Outputs for submit_answer — 7 values
+    RES_OUT = [session, listen_col, quiz_col, result_col, cert_col,
+               result_md, submit_btn, answer_box]
+    submit_btn.click(submit_answer, inputs=[answer_box, session], outputs=RES_OUT)
+    answer_box.submit(submit_answer, inputs=[answer_box, session], outputs=RES_OUT)
+
+    next_btn.click(handle_next, inputs=[session], outputs=LISTEN_OUT)
+    restart_btn.click(restart_from_cert, inputs=[session], outputs=LISTEN_OUT)
+
+if __name__ == "__main__":
+    demo.queue()
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)
+"""
+Cours de Droit – Hugging Face Space  (Gradio 5 compatible)
+"""
+import os, json, time, tempfile, random, threading
+import requests
+import gradio as gr
+from gtts import gTTS
+
+# ── llama-server connection ───────────────────────────────────────────────────
+LLAMA_URL     = os.getenv("LLAMA_SERVER_URL", "http://127.0.0.1:8080")
+CHAT_ENDPOINT = f"{LLAMA_URL}/v1/chat/completions"
+_server_ok    = False
+
+def _check_server():
+    global _server_ok
+    for _ in range(60):
+        try:
+            r = requests.get(f"{LLAMA_URL}/health", timeout=2)
+            if r.status_code == 200:
+                _server_ok = True
+                print("[law-app] llama-server ready ✓")
+                return
+        except Exception:
+            pass
+        time.sleep(2)
+    print("[law-app] llama-server not reachable – keyword fallback active")
+
+threading.Thread(target=_check_server, daemon=True).start()
+
+# ── Leçons ────────────────────────────────────────────────────────────────────
+with open("lessons.json") as f:
+    LESSONS = json.load(f)
+
+LISTEN_SECONDS = 900  # 15 min  (set to 10 for testing)
+PASS_SCORE     = 6
+
+# ── Cache audio ───────────────────────────────────────────────────────────────
+_audio_cache = {}
+_audio_lock  = threading.Lock()
+
+def get_lecture_audio(lesson_idx):
+    if lesson_idx in _audio_cache and os.path.exists(_audio_cache[lesson_idx]):
+        return _audio_cache[lesson_idx]
+    with _audio_lock:
+        if lesson_idx in _audio_cache and os.path.exists(_audio_cache[lesson_idx]):
+            return _audio_cache[lesson_idx]
+        try:
+            tts  = gTTS(text=LESSONS[lesson_idx]["text"], lang="fr", slow=False)
+            path = tempfile.mktemp(suffix=".mp3")
+            tts.save(path)
+            _audio_cache[lesson_idx] = path
+            return path
+        except Exception as e:
+            print(f"[law-app] gTTS erreur : {e}")
+            return None
+
+# ── État ──────────────────────────────────────────────────────────────────────
+def fresh():
+    return {"phase": "idle", "listen_start": None, "question_idx": None, "lesson_idx": 0}
+
+# ── Évaluation ────────────────────────────────────────────────────────────────
+_SYSTEM_PROMPT = (
+    "Tu es un professeur de droit français strict et bienveillant. "
+    "Tu évalues les réponses des étudiants et réponds UNIQUEMENT en JSON valide sur une seule ligne.\n\n"
+    "Exemple :\n"
+    "Question : Quelles sont les finalités de l'action publique et de l'action civile ?\n"
+    "Réponse : je ne sais pas\n"
+    'Réponse attendue : {"score": 0, "feedback": "Aucune réponse proposée."}'
+)
+
+def _keyword_fallback(answer, hint, reason=""):
+    kw    = [w.strip().lower() for w in hint.split(",")]
+    hits  = sum(1 for k in kw if k in answer.lower())
+    score = min(10, round((hits / max(len(kw), 1)) * 10))
+    return score, f"(Sans IA – {reason} – mots-clés : {hits}/{len(kw)})"
+
+def evaluate_answer(question, answer, hint):
+    if not _server_ok:
+        return _keyword_fallback(answer, hint, "serveur indisponible")
+    user_msg = (
+        f"Question : {question}\nRéponse : {answer}\nÉléments attendus : {hint}\n\n"
+        'Réponds UNIQUEMENT avec ce JSON sur une seule ligne : {"score": <0-10>, "feedback": "<commentaire>"}'
+    )
+    try:
+        resp = requests.post(CHAT_ENDPOINT, json={
+            "model": "local",
+            "messages": [{"role": "system", "content": _SYSTEM_PROMPT},
+                         {"role": "user",   "content": user_msg}],
+            "max_tokens": 150, "temperature": 0.1, "stop": ["\n\n"],
+        }, timeout=60)
+        resp.raise_for_status()
+        text  = resp.json()["choices"][0]["message"]["content"].strip()
+        start = text.find("{"); end = text.rfind("}") + 1
+        data  = json.loads(text[start:end])
+        return max(0, min(10, int(data["score"]))), data.get("feedback", "")
+    except Exception as e:
+        return _keyword_fallback(answer, hint, str(e))
+
+# ── UI ────────────────────────────────────────────────────────────────────────
+CSS = "footer{display:none!important;} #title{text-align:center;}"
+
+with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
+    session = gr.State(fresh())
+
+    gr.Markdown(
+        "# ⚖️ Cours de Droit — Formation Juridique\n"
+        "Écoutez chaque leçon · Répondez à la question · Progressez leçon par leçon",
+        elem_id="title",
+    )
+
+    # ── Panels ────────────────────────────────────────────────────────────────
+    with gr.Column(visible=True) as listen_col:
+        gr.Markdown("## 🎧 Étape 1 — Écoute de la leçon")
+        listen_msg = gr.Markdown("Cliquez sur **Démarrer** pour commencer.")
+        audio_out  = gr.Audio(label="Cours audio (français)", autoplay=False, interactive=False)
+        timer_info = gr.Markdown("")
+        with gr.Row():
+            start_btn = gr.Button("▶️ Démarrer l'écoute", variant="primary")
+            check_btn = gr.Button("🔄 Vérifier le temps",  variant="secondary")
+            quiz_btn  = gr.Button("✅ Accéder au Quiz",    variant="secondary", interactive=False)
+
+    with gr.Column(visible=False) as quiz_col:
+        gr.Markdown("## 📝 Étape 2 — Question d'évaluation")
+        question_md = gr.Markdown("")
+        answer_box  = gr.Textbox(label="Votre réponse", placeholder="Rédigez ici…", lines=5)
+        submit_btn  = gr.Button("📤 Soumettre", variant="primary")
+
+    with gr.Column(visible=False) as result_col:
+        gr.Markdown("## 📊 Résultat")
+        result_md = gr.Markdown("")
+        next_btn  = gr.Button("➡️ Leçon suivante", variant="primary")
+
+    with gr.Column(visible=False) as cert_col:
+        cert_md     = gr.Markdown("")
+        restart_btn = gr.Button("🔄 Recommencer depuis le début", variant="secondary")
+
+    # ── Handlers ──────────────────────────────────────────────────────────────
+    def start_listening(state):
+        lesson_idx = state.get("lesson_idx", 0)
+        lesson     = LESSONS[lesson_idx]
+        state      = {**state, "phase": "listen", "listen_start": time.time(), "question_idx": None}
+        audio      = get_lecture_audio(lesson_idx)
+        total      = len(LESSONS)
+        msg = (
+            f"🎧 **{lesson['title']}** ({lesson_idx + 1}/{total})\n\n"
+            "Écoutez pendant **15 minutes** complètes, puis cliquez sur **🔄 Vérifier le temps**."
+        )
+        return (
+            state,
+            audio,
+            msg,
+            gr.update(visible=True),                              # listen_col
+            gr.update(visible=False),                             # quiz_col
+            gr.update(visible=False),                             # result_col
+            gr.update(visible=False),                             # cert_col
+            gr.update(interactive=False, value="⏳ Écoute en cours…"),  # quiz_btn
+        )
+
+    def check_timer(state):
+        if state["phase"] != "listen" or not state["listen_start"]:
+            return gr.update(), "⚠️ Lancez d'abord l'écoute.", state
+        rem  = max(0, LISTEN_SECONDS - (time.time() - state["listen_start"]))
+        m, s = divmod(int(rem), 60)
+        if rem <= 0:
+            return (
+                gr.update(interactive=True, value="✅ Accéder au Quiz"),
+                "✅ Durée atteinte ! Cliquez sur **Accéder au Quiz**.",
+                state,
+            )
+        return (
+            gr.update(interactive=False, value=f"⏳ Encore {m:02d}:{s:02d}"),
+            f"🎧 Patientez encore **{m} min {s:02d} s**.",
+            state,
+        )
+
+    # ── FIX: open_quiz ─────────────────────────────────────────────────────────
+    # Previously the early-return branch had mismatched gr.update() calls,
+    # causing the quiz column to never become visible.  We now:
+    #   1. Guard against missing/empty questions list.
+    #   2. Use gr.update() (no args) for components we don't want to touch in
+    #      the early-return path instead of gr.update(value="") which can
+    #      collide with Gradio 5's diffing logic.
+    #   3. Keep listen_col visible (not hidden) in the early-return path so the
+    #      user still sees the timer message.
+    def open_quiz(state):
+        elapsed = time.time() - (state.get("listen_start") or 0)
+
+        # ── Timer not elapsed yet ──
+        if elapsed < LISTEN_SECONDS:
+            m, s = divmod(int(LISTEN_SECONDS - elapsed), 60)
+            return (
+                state,
+                gr.update(visible=True),   # listen_col  — keep showing
+                gr.update(visible=False),  # quiz_col    — stay hidden
+                gr.update(visible=False),  # result_col
+                gr.update(visible=False),  # cert_col
+                gr.update(value=f"⚠️ Patientez encore **{m} min {s:02d} s**."),  # timer_info
+                gr.update(),               # question_md — no change
+                gr.update(),               # answer_box  — no change
+            )
+
+        lesson_idx = state.get("lesson_idx", 0)
+        questions  = LESSONS[lesson_idx].get("questions", [])
+
+        # ── Guard: no questions defined for this lesson ──
+        if not questions:
+            return (
+                state,
+                gr.update(visible=True),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="⚠️ Aucune question disponible pour cette leçon."),
+                gr.update(),
+                gr.update(),
+            )
+
+        idx           = random.randrange(len(questions))
+        state         = {**state, "phase": "quiz", "question_idx": idx}
+        question_text = questions[idx]["q"]
+
+        return (
+            state,
+            gr.update(visible=False),          # listen_col  — hide
+            gr.update(visible=True),           # quiz_col    — SHOW ← the key fix
+            gr.update(visible=False),          # result_col
+            gr.update(visible=False),          # cert_col
+            gr.update(value=""),               # timer_info  — clear
+            gr.update(value=question_text),    # question_md — set question
+            gr.update(value=""),               # answer_box  — clear previous answer
+        )
+
+    def submit_answer(answer, state):
+        lesson_idx = state.get("lesson_idx", 0)
+
+        if state["phase"] != "quiz":
+            yield (
+                state,
+                gr.update(visible=True),  gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=False),
+                "",
+                gr.update(value="📤 Soumettre", interactive=True),
+                gr.update(interactive=True),
+            )
+            return
+
+        # Step 1: disable buttons immediately while evaluating
+        yield (
+            state,
+            gr.update(visible=False), gr.update(visible=True),
+            gr.update(visible=False), gr.update(visible=False),
+            "",
+            gr.update(value="⏳ Correction en cours…", interactive=False),
+            gr.update(interactive=False),
+        )
+
+        # Step 2: evaluate
+        q         = LESSONS[lesson_idx]["questions"][state["question_idx"]]
+        score, fb = evaluate_answer(q["q"], answer, q["hint"])
+        total     = len(LESSONS)
+
+        if score >= PASS_SCORE:
+            state  = {**state, "phase": "pass"}
+            result = (
+                f"## 🎉 Bravo ! Leçon {lesson_idx + 1}/{total} réussie.\n\n"
+                f"**Score : {score}/10**\n\n**Commentaire :** {fb}"
+            )
         else:
-            state = {**state, "lesson_idx": lesson_idx + 1, "listen_start": None}
+            state  = {**state, "phase": "fail"}
+            result = (
+                f"## ❌ Score insuffisant : {score}/10\n\n"
+                f"**Commentaire :** {fb}\n\n"
+                f"Seuil requis : **{PASS_SCORE}/10**. Veuillez **réécouter la leçon** avant de retenter."
+            )
+
+        # Step 3: show result panel
+        yield (
+            state,
+            gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=True),  gr.update(visible=False),
+            result,
+            gr.update(value="📤 Soumettre", interactive=True),
+            gr.update(value="", interactive=True),
+        )
+
+    def handle_next(state):
+        lesson_idx = state.get("lesson_idx", 0)
+        total      = len(LESSONS)
+
+        # Failed → restart the same lesson's listening phase
+        if state["phase"] == "fail":
             return start_listening(state)
 
+        # Passed last lesson → show certificate
+        if lesson_idx >= total - 1:
+            state = {**state, "phase": "done"}
+            # Build dynamic checklist from actual lesson titles
+            checklist = "\n\n".join(
+                f"✅ Leçon {i + 1} — {LESSONS[i]['title']}"
+                for i in range(total)
+            )
+            cert = (
+                "# 🏆 Félicitations !\n\n"
+                f"Vous avez complété avec succès les **{total} leçons** du cours :\n\n"
+                f"{checklist}\n\n"
+                "---\n\n*Ce certificat atteste de votre réussite aux évaluations.*"
+            )
+            return (
+                state, None, cert,
+                gr.update(visible=False), gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=True),
+                gr.update(interactive=False, value="✅ Terminé"),
+            )
+
+        # Passed → advance to next lesson
+        state = {**state, "lesson_idx": lesson_idx + 1, "listen_start": None}
+        return start_listening(state)
+
     def restart_from_cert(state):
         return start_listening(fresh())
 
     # ── Wiring ────────────────────────────────────────────────────────────────
+    # Outputs shared by start_listening / handle_next / restart_from_cert
     LISTEN_OUT = [session, audio_out, listen_msg,
                   listen_col, quiz_col, result_col, cert_col, quiz_btn]
 
-    start_btn.click(start_listening, [session], LISTEN_OUT)
+    start_btn.click(start_listening, inputs=[session], outputs=LISTEN_OUT)
 
-    check_btn.click(check_timer, [session], [quiz_btn, timer_info, session])
+    check_btn.click(check_timer, inputs=[session], outputs=[quiz_btn, timer_info, session])
 
+    # Outputs for open_quiz — must match exactly what open_quiz() returns (8 values)
     QUIZ_OUT = [session, listen_col, quiz_col, result_col, cert_col,
                 timer_info, question_md, answer_box]
-    quiz_btn.click(open_quiz, [session], QUIZ_OUT)
+    quiz_btn.click(open_quiz, inputs=[session], outputs=QUIZ_OUT)
 
+    # Outputs for submit_answer — 7 values
     RES_OUT = [session, listen_col, quiz_col, result_col, cert_col,
                result_md, submit_btn, answer_box]
-    submit_btn.click(submit_answer, [answer_box, session], RES_OUT)
-    answer_box.submit(submit_answer, [answer_box, session], RES_OUT)
+    submit_btn.click(submit_answer, inputs=[answer_box, session], outputs=RES_OUT)
+    answer_box.submit(submit_answer, inputs=[answer_box, session], outputs=RES_OUT)
 
-    next_btn.click(handle_next, [session], LISTEN_OUT)
-    restart_btn.click(restart_from_cert, [session], LISTEN_OUT)
+    next_btn.click(handle_next, inputs=[session], outputs=LISTEN_OUT)
+    restart_btn.click(restart_from_cert, inputs=[session], outputs=LISTEN_OUT)
 
 if __name__ == "__main__":
     demo.queue()
     demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)
 
+