Update app.py

app.py

@@ -1,17 +1,34 @@
 """
 Cours de Droit – Hugging Face Space
-===================================
-Workflow:
-  1. L'étudiant écoute le cours audio (français, gTTS) pendant 15 minutes.
-  2. Après 15 min une question aléatoire apparaît (réponse ouverte).
-  3. Qwen3-0.6B-Q4_K_M (llama-cpp) évalue la réponse de 0 à 10.
-  4. Score ≥ 6 → réussi. Score < 6 → retour au début, réécoute obligatoire.
-Multi-utilisateur sécurisé via gr.State (JSON par session).
-Compatible gradio 5.x + Python 3.13.
+Compatible avec le Docker HF (gradio 4.44.1 bundled + Python 3.13).
 """
 
-import os, glob, json, time, tempfile, random, threading
+# ── Fix Python 3.13: audioop supprimé, pyaudioop le remplace ─────────────────
+import sys
+try:
+    import pyaudioop
+    sys.modules["audioop"] = pyaudioop
+except ImportError:
+    pass
+# ─────────────────────────────────────────────────────────────────────────────
+
 import gradio as gr
+
+# ── Patch gradio_client 0.8 schema bug (gradio 4.44) ─────────────────────────
+try:
+    import gradio_client.utils as _gcu
+    import gradio.blocks as _gb
+    _orig = _gcu.json_schema_to_python_type
+    def _safe(schema):
+        try: return _orig(schema)
+        except Exception: return "Any"
+    _gcu.json_schema_to_python_type = _safe
+    _gb.client_utils.json_schema_to_python_type = _safe
+except Exception:
+    pass
+# ─────────────────────────────────────────────────────────────────────────────
+
+import os, glob, json, time, tempfile, random, threading
 from gtts import gTTS
 
 try:
@@ -35,9 +52,9 @@ def get_llm():
             return _llm
         paths = glob.glob("/app/*.gguf") + glob.glob("*.gguf")
         if not paths:
-            print("[law-app] Aucun fichier .gguf trouvé – évaluation IA désactivée.")
+            print("[law-app] Aucun .gguf trouvé – évaluation IA désactivée.")
             return None
-        print(f"[law-app] Chargement du modèle : {paths[0]}")
+        print(f"[law-app] Chargement : {paths[0]}")
         _llm = Llama(
             model_path=paths[0],
             n_ctx=1024,
@@ -48,7 +65,7 @@ def get_llm():
         print("[law-app] Modèle prêt.")
         return _llm
 
-# ── Contenu du cours (droit civil français) ───────────────────────────────────
+# ── Texte du cours ────────────────────────────────────────────────────────────
 LECTURE_TEXT = """
 Cours de droit civil. Introduction aux sources du droit français.
 
@@ -82,120 +99,75 @@ La jurisprudence, bien qu'elle ne soit pas officiellement reconnue
 comme source formelle, joue un rôle fondamental dans le système
 juridique français. Les décisions de la Cour de cassation et du
 Conseil d'État interprètent et précisent la portée des textes légaux.
-Le Conseil constitutionnel, par ses décisions, contrôle la
-constitutionnalité des lois.
+Le Conseil constitutionnel contrôle la constitutionnalité des lois.
 
 La doctrine regroupe l'ensemble des travaux des juristes :
-professeurs, avocats, magistrats. Elle propose des analyses,
-des systématisations et des critiques du droit positif.
-Sans force obligatoire, elle influence néanmoins la jurisprudence
-et le législateur.
+professeurs, avocats, magistrats. Sans force obligatoire, elle influence
+néanmoins la jurisprudence et le législateur.
 
 La coutume, source ancienne, est aujourd'hui d'application limitée.
-Elle consiste en une pratique ancienne, constante et répétée,
-acceptée comme obligatoire par la population. En droit commercial,
-les usages professionnels conservent une importance certaine.
+En droit commercial, les usages professionnels conservent une importance certaine.
 
 Troisième partie : Le principe de hiérarchie des normes.
 
 Hans Kelsen, juriste autrichien du vingtième siècle, a théorisé
-la pyramide des normes. Selon cette théorie, chaque norme tire
-sa validité d'une norme supérieure. En France, le Conseil
-constitutionnel assure le respect de cette hiérarchie en contrôlant
-la conformité des lois à la Constitution.
-
-Le contrôle de légalité permet quant à lui de vérifier que les
-actes administratifs sont conformes aux lois qui leur sont
-supérieures. Tout acte contraire à une norme supérieure est
-susceptible d'être annulé ou écarté.
+la pyramide des normes. Chaque norme tire sa validité d'une norme supérieure.
+En France, le Conseil constitutionnel assure le respect de cette hiérarchie.
 
 Quatrième partie : Le droit des contrats.
 
-Le contrat est un accord de volontés entre deux ou plusieurs
-personnes destiné à créer, modifier, transmettre ou éteindre
-des obligations. Le Code civil, dans sa rédaction issue de
-l'ordonnance du 10 février 2016, définit les conditions de
-validité du contrat : le consentement des parties, leur capacité
+Le contrat est un accord de volontés destiné à créer, modifier, transmettre
+ou éteindre des obligations. Le Code civil, issu de l'ordonnance du 10 février 2016,
+définit trois conditions de validité : le consentement des parties, leur capacité
 à contracter, et un contenu licite et certain.
 
-Le consentement doit être libre et éclairé. Il est vicié lorsqu'il
-a été donné par erreur, obtenu par dol ou arraché par violence.
-Dans ces cas, le contrat peut être annulé à la demande de la
-partie dont le consentement a été vicié.
+Le consentement doit être libre et éclairé. Il est vicié par l'erreur, le dol
+ou la violence. L'incapacité concerne les mineurs non émancipés et les majeurs
+protégés sous tutelle ou curatelle.
 
-La capacité contractuelle est la règle. L'incapacité est
-l'exception et concerne principalement les mineurs non émancipés
-et les majeurs protégés sous tutelle ou curatelle.
-
-L'exécution du contrat obéit au principe de la force obligatoire :
-le contrat tient lieu de loi entre les parties qui l'ont conclu.
-En cas d'inexécution, la partie lésée dispose de plusieurs recours :
-l'exécution forcée, la résolution du contrat ou des dommages et intérêts.
+L'exécution obéit au principe de la force obligatoire : le contrat tient lieu
+de loi entre les parties. En cas d'inexécution : exécution forcée, résolution
+ou dommages et intérêts.
 
 Cinquième partie : La responsabilité civile.
 
-La responsabilité civile a pour fonction de réparer le préjudice
-causé à autrui. Elle se distingue de la responsabilité pénale
-qui vise à sanctionner l'auteur d'une infraction.
-
-La responsabilité délictuelle repose sur trois conditions :
-une faute, un dommage et un lien de causalité entre les deux.
-L'article 1240 du Code civil dispose que tout fait quelconque
-de l'homme qui cause à autrui un dommage oblige son auteur
-à le réparer.
-
-La responsabilité sans faute, dite objective, est reconnue
-dans certains cas : responsabilité du fait des choses,
-responsabilité du fait d'autrui, responsabilité des produits
-défectueux. L'évolution jurisprudentielle et législative tend
-à élargir ces hypothèses pour mieux protéger les victimes.
-
-Conclusion : Le droit est un système dynamique en constante évolution.
-La maîtrise de ses sources et de ses principes fondamentaux est
-indispensable à tout juriste. La rigueur dans l'analyse textuelle,
-combinée à la connaissance de la jurisprudence, permet d'appliquer
-le droit de manière correcte et juste.
+La responsabilité civile répare le préjudice causé à autrui, contrairement
+à la responsabilité pénale qui sanctionne l'auteur d'une infraction.
+
+La responsabilité délictuelle repose sur trois conditions : faute, dommage
+et lien de causalité. L'article 1240 du Code civil dispose que tout fait
+de l'homme causant un dommage oblige son auteur à le réparer.
+
+La responsabilité sans faute couvre le fait des choses, le fait d'autrui
+et les produits défectueux.
+
+Conclusion : la maîtrise des sources et des principes fondamentaux du droit
+est indispensable à tout juriste.
 """
 
 QUESTIONS = [
-    {
-        "q": "Quelle est la source au sommet de la hiérarchie des normes en droit français, et quelle est sa date ?",
-        "hint": "Constitution, 4 octobre 1958, loi fondamentale",
-    },
-    {
-        "q": "Quelles sont les trois conditions de validité d'un contrat selon le Code civil réformé en 2016 ?",
-        "hint": "consentement, capacité, contenu licite et certain",
-    },
-    {
-        "q": "Qu'est-ce que la pyramide des normes et qui en est le théoricien ?",
-        "hint": "Hans Kelsen, hiérarchie des normes, validité tirée d'une norme supérieure",
-    },
-    {
-        "q": "Quels sont les trois vices du consentement qui peuvent entraîner la nullité d'un contrat ?",
-        "hint": "erreur, dol, violence",
-    },
-    {
-        "q": "Quelles sont les trois conditions nécessaires pour engager la responsabilité délictuelle ?",
-        "hint": "faute, dommage, lien de causalité, article 1240 Code civil",
-    },
-    {
-        "q": "Expliquez la différence entre la responsabilité civile et la responsabilité pénale.",
-        "hint": "civile répare le préjudice, pénale sanctionne l'auteur d'une infraction",
-    },
-    {
-        "q": "Quel est le rôle de la jurisprudence dans le système juridique français ?",
-        "hint": "interprète et précise la portée des textes légaux, Cour de cassation, Conseil d'État",
-    },
-    {
-        "q": "Quelles personnes sont frappées d'incapacité contractuelle en droit français ?",
-        "hint": "mineurs non émancipés, majeurs protégés sous tutelle ou curatelle",
-    },
+    {"q": "Quelle est la source au sommet de la hiérarchie des normes en droit français, et quelle est sa date ?",
+     "hint": "Constitution, 4 octobre 1958, loi fondamentale"},
+    {"q": "Quelles sont les trois conditions de validité d'un contrat selon le Code civil réformé en 2016 ?",
+     "hint": "consentement, capacité, contenu licite et certain"},
+    {"q": "Qu'est-ce que la pyramide des normes et qui en est le théoricien ?",
+     "hint": "Hans Kelsen, hiérarchie des normes, validité tirée d'une norme supérieure"},
+    {"q": "Quels sont les trois vices du consentement qui peuvent entraîner la nullité d'un contrat ?",
+     "hint": "erreur, dol, violence"},
+    {"q": "Quelles sont les trois conditions de la responsabilité délictuelle ?",
+     "hint": "faute, dommage, lien de causalité, article 1240 Code civil"},
+    {"q": "Quelle est la différence entre responsabilité civile et responsabilité pénale ?",
+     "hint": "civile répare le préjudice, pénale sanctionne l'auteur d'une infraction"},
+    {"q": "Quel est le rôle de la jurisprudence dans le système juridique français ?",
+     "hint": "interprète et précise les textes légaux, Cour de cassation, Conseil d'État"},
+    {"q": "Quelles personnes sont frappées d'incapacité contractuelle en droit français ?",
+     "hint": "mineurs non émancipés, majeurs protégés sous tutelle ou curatelle"},
 ]
 
-LISTEN_SECONDS = 15 * 60   # 15 minutes
+LISTEN_SECONDS = 15 * 60
 PASS_SCORE     = 6
 
-# ── Audio cache (partagé entre sessions) ─────────────────────────────────────
+# ── Audio cache ───────────────────────────────────────────────────────────────
 _audio_cache = None
 _audio_lock  = threading.Lock()
 
@@ -216,78 +188,66 @@ def get_lecture_audio():
             print(f"[law-app] gTTS erreur : {e}")
             return None
 
-# ── État de session ────────────────────────────────────────────────────────────
+# ── État ──────────────────────────────────────────────────────────────────────
 def fresh():
-    return json.dumps({
-        "phase":        "idle",
-        "listen_start": None,
-        "question_idx": None,
-    })
+    return json.dumps({"phase": "idle", "listen_start": None, "question_idx": None})
 
 def S(s): return json.loads(s)
 def D(d): return json.dumps(d)
 
-# ── Évaluation Qwen3 ──────────────────────────────────────────────────────────
-def evaluate_answer(question: str, answer: str, hint: str):
+# ── Évaluation ────────────────────────────────────────────────────────────────
+def evaluate_answer(question, answer, hint):
     llm = get_llm()
     if llm is None:
-        keywords = [w.strip().lower() for w in hint.split(",")]
-        ans_low  = answer.lower()
-        hits     = sum(1 for k in keywords if k in ans_low)
-        score    = min(10, round((hits / max(len(keywords), 1)) * 10))
-        return score, f"(Évaluation sans IA – mots-clés trouvés : {hits}/{len(keywords)})"
-
+        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 – mots-clés : {hits}/{len(kw)})"
     prompt = (
-        f"Tu es un professeur de droit strict mais juste.\n"
+        f"Tu es un professeur de droit.\n"
         f"Question : {question}\n"
-        f"Réponse de l'étudiant : {answer}\n"
+        f"Réponse : {answer}\n"
         f"Éléments attendus : {hint}\n\n"
-        "Évalue la réponse de 0 à 10. Réponds UNIQUEMENT avec un JSON sur une seule ligne, "
-        'sans texte avant ni après : {"score": <entier 0-10>, "feedback": "<commentaire bref en français>"}'
+        "Réponds UNIQUEMENT avec ce JSON sur une ligne : "
+        '{"score": <0-10>, "feedback": "<commentaire bref en français>"}'
     )
     try:
-        out  = llm(prompt, max_tokens=200, temperature=0.1, stop=["###", "\n\n"])
+        out  = llm(prompt, max_tokens=150, temperature=0.1, stop=["###", "\n\n"])
         text = out["choices"][0]["text"].strip()
         data = json.loads(text[text.find("{"):text.rfind("}")+1])
         return max(0, min(10, int(data["score"]))), data.get("feedback", "")
     except Exception as e:
-        print(f"[law-app] Erreur évaluation : {e}")
-        return 0, "Erreur lors de l'évaluation. Veuillez réessayer."
+        print(f"[law-app] Erreur éval : {e}")
+        return 0, "Erreur d'évaluation, réessayez."
 
 # ── Handlers ──────────────────────────────────────────────────────────────────
-
 def start_listening(ss):
     state = S(ss)
-    state["phase"]        = "listen"
-    state["listen_start"] = time.time()
+    state.update({"phase": "listen", "listen_start": time.time(), "question_idx": None})
     audio = get_lecture_audio()
     msg   = (
         "🎧 **Cours en cours d'écoute…**\n\n"
-        "Vous devez écouter pendant **15 minutes** complètes avant d'accéder au quiz.\n\n"
-        "Cliquez sur **🔄 Vérifier le temps** pour voir combien il reste."
+        "Écoutez pendant **15 minutes** complètes, puis cliquez sur **🔄 Vérifier le temps**."
     )
     return (
-        audio,
-        msg,
-        gr.update(visible=True),    # listen_group
-        gr.update(visible=False),   # quiz_group
-        gr.update(visible=False),   # result_group
+        audio, msg,
+        gr.update(visible=True),    # listen_col
+        gr.update(visible=False),   # quiz_col
+        gr.update(visible=False),   # result_col
         gr.update(interactive=False, value="⏳ Écoute en cours…"),
         D(state),
     )
 
-
 def check_timer(ss):
-    state   = S(ss)
-    if state["phase"] != "listen" or state["listen_start"] is None:
+    state = S(ss)
+    if state["phase"] != "listen" or not state["listen_start"]:
         return gr.update(), "⚠️ Lancez d'abord l'écoute.", ss
-    elapsed   = time.time() - state["listen_start"]
-    remaining = max(0, LISTEN_SECONDS - elapsed)
-    m, s      = divmod(int(remaining), 60)
-    if remaining <= 0:
+    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 d'écoute atteinte ! Cliquez sur **Accéder au Quiz**.",
+            "✅ Durée atteinte ! Cliquez sur **Accéder au Quiz**.",
             ss,
         )
     return (
@@ -296,49 +256,33 @@ def check_timer(ss):
         ss,
     )
 
-
 def open_quiz(ss):
     state   = S(ss)
     elapsed = time.time() - (state["listen_start"] or 0)
     if elapsed < LISTEN_SECONDS:
         m, s = divmod(int(LISTEN_SECONDS - elapsed), 60)
         return (
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            f"⚠️ Patientez encore **{m} min {s:02d} s**.",
-            "", "", ss,
+            gr.update(visible=True), gr.update(visible=False), gr.update(visible=False),
+            f"⚠️ Patientez encore **{m} min {s:02d} s**.", "", "", ss,
         )
     idx = random.randrange(len(QUESTIONS))
-    state["phase"]        = "quiz"
-    state["question_idx"] = idx
+    state.update({"phase": "quiz", "question_idx": idx})
     return (
-        gr.update(visible=False),
-        gr.update(visible=True),
-        gr.update(visible=False),
-        "",
-        QUESTIONS[idx]["q"],
-        "",
-        D(state),
+        gr.update(visible=False), gr.update(visible=True), gr.update(visible=False),
+        "", QUESTIONS[idx]["q"], "", D(state),
     )
 
-
 def submit_answer(answer, ss):
     state = S(ss)
     if state["phase"] != "quiz":
         return gr.update(visible=True), gr.update(visible=False), "", "", ss
-
-    idx          = state["question_idx"]
-    q            = QUESTIONS[idx]
+    q            = QUESTIONS[state["question_idx"]]
     score, fb    = evaluate_answer(q["q"], answer, q["hint"])
-
     if score >= PASS_SCORE:
         state["phase"] = "pass"
         result = (
             f"## 🎉 Félicitations ! Vous avez réussi.\n\n"
-            f"**Score : {score}/10**\n\n"
-            f"**Commentaire :** {fb}\n\n"
-            f"---\n*Vous maîtrisez bien ce cours de droit civil.*"
+            f"**Score : {score}/10**\n\n**Commentaire :** {fb}"
         )
         btn = "🔄 Recommencer"
     else:
@@ -346,43 +290,30 @@ def submit_answer(answer, ss):
         result = (
             f"## ❌ Score insuffisant : {score}/10\n\n"
             f"**Commentaire :** {fb}\n\n"
-            f"---\n"
-            f"Seuil requis : **{PASS_SCORE}/10**.\n\n"
-            f"⬇️ Veuillez **réécouter l'intégralité du cours** (15 minutes) "
-            f"avant de tenter à nouveau le quiz."
+            f"Seuil requis : **{PASS_SCORE}/10**. "
+            f"Veuillez **réécouter le cours complet** avant de retenter."
         )
         btn = "🔄 Réécouter le cours"
-
-    return (
-        gr.update(visible=False),
-        gr.update(visible=True),
-        result,
-        btn,
-        D(state),
-    )
-
+    return gr.update(visible=False), gr.update(visible=True), result, btn, D(state)
 
 def restart(ss):
     return start_listening(fresh())
 
-
-# ── Interface ──────────────────────────���──────────────────────────────────────
+# ── 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 le cours en français · Répondez à une question · Obtenez une note sur 10",
+        "Écoutez le cours · Répondez à la question · Note sur 10 par l'IA",
         elem_id="title",
     )
 
-    # ── Phase écoute ─────────────────────────────────────────────────────────
-    with gr.Group(visible=True) as listen_group:
+    with gr.Column(visible=True) as listen_col:
         gr.Markdown("## 🎧 Étape 1 — Écoute du cours (15 minutes)")
-        listen_msg = gr.Markdown("Cliquez sur **Démarrer l'écoute** pour commencer.")
+        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():
@@ -390,37 +321,30 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
             check_btn = gr.Button("🔄 Vérifier le temps",  variant="secondary")
             quiz_btn  = gr.Button("✅ Accéder au Quiz",    variant="secondary", interactive=False)
 
-    # ── Phase quiz ───────────────────────────────────────────────────────────
-    with gr.Group(visible=False) as quiz_group:
+    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 votre réponse ici…",
-            lines=5,
-        )
-        submit_btn = gr.Button("📤 Soumettre la réponse", variant="primary")
+        answer_box  = gr.Textbox(label="Votre réponse", placeholder="Rédigez ici…", lines=5)
+        submit_btn  = gr.Button("📤 Soumettre", variant="primary")
 
-    # ── Phase résultat ───────────────────────────────────────────────────────
-    with gr.Group(visible=False) as result_group:
+    with gr.Column(visible=False) as result_col:
         gr.Markdown("## 📊 Résultat")
         result_md   = gr.Markdown("")
         restart_btn = gr.Button("🔄 Recommencer", variant="secondary")
 
-    # ── Câblage ───────────────────────────────────────────────────────────────
-    START_OUT = [audio_out, listen_msg, listen_group, quiz_group, result_group, quiz_btn, session]
-
-    start_btn.click(start_listening, [session], START_OUT)
+    # Câblage
+    START = [audio_out, listen_msg, listen_col, quiz_col, result_col, quiz_btn, session]
+    start_btn.click(start_listening, [session], START)
     check_btn.click(check_timer,     [session], [quiz_btn, timer_info, session])
 
-    QUIZ_OUT = [listen_group, quiz_group, result_group, timer_info, question_md, answer_box, session]
-    quiz_btn.click(open_quiz, [session], QUIZ_OUT)
+    QUIZ = [listen_col, quiz_col, result_col, timer_info, question_md, answer_box, session]
+    quiz_btn.click(open_quiz, [session], QUIZ)
 
-    RESULT_OUT = [quiz_group, result_group, result_md, restart_btn, session]
-    submit_btn.click(submit_answer, [answer_box, session], RESULT_OUT)
-    answer_box.submit(submit_answer, [answer_box, session], RESULT_OUT)
+    RES = [quiz_col, result_col, result_md, restart_btn, session]
+    submit_btn.click(submit_answer, [answer_box, session], RES)
+    answer_box.submit(submit_answer, [answer_box, session], RES)
 
-    restart_btn.click(restart, [session], START_OUT)
+    restart_btn.click(restart, [session], START)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)