Update app.py

app.py

@@ -1,6 +1,7 @@
 """
 Cours de Droit – Hugging Face Space
 Compatible avec le Docker HF (gradio 4.44.1 bundled + Python 3.13).
+Téléchargement automatique du modèle au démarrage.
 """
 
 import sys
@@ -24,8 +25,9 @@ try:
 except Exception:
     pass
 
-import os, glob, json, time, tempfile, random, threading
+import os, json, time, tempfile, random, threading
 from gtts import gTTS
+from huggingface_hub import hf_hub_download
 
 try:
     from llama_cpp import Llama
@@ -33,28 +35,51 @@ try:
 except ImportError:
     _LLAMA_OK = False
 
+# ── Téléchargement et chargement du modèle ────────────────────────────────────
 _llm      = None
 _llm_lock = threading.Lock()
 
+def download_model():
+    model_path = "/app/model.gguf"
+    if os.path.exists(model_path):
+        print("[law-app] Modèle déjà présent.")
+        return model_path
+    print("[law-app] Téléchargement du modèle en cours...")
+    try:
+        path = hf_hub_download(
+            repo_id="Qwen/Qwen2.5-0.5B-Instruct-GGUF",
+            filename="qwen2.5-0.5b-instruct-q4_k_m.gguf",
+            local_dir="/app",
+            local_dir_use_symlinks=False,
+        )
+        if path != model_path:
+            os.rename(path, model_path)
+        print("[law-app] Téléchargement terminé.")
+        return model_path
+    except Exception as e:
+        print(f"[law-app] Erreur téléchargement : {e}")
+        return None
+
 def get_llm():
     global _llm
     if _llm is not None:
         return _llm
     if not _LLAMA_OK:
+        print("[law-app] llama_cpp non disponible.")
         return None
     with _llm_lock:
         if _llm is not None:
             return _llm
-        paths = glob.glob("/app/*.gguf") + glob.glob("*.gguf")
-        if not paths:
-            print("[law-app] Aucun .gguf trouvé – évaluation IA désactivée.")
+        model_path = download_model()
+        if not model_path or not os.path.exists(model_path):
+            print("[law-app] Modèle introuvable.")
             return None
-        print(f"[law-app] Chargement : {paths[0]}")
+        print(f"[law-app] Chargement : {model_path}")
         _llm = Llama(
-            model_path=paths[0],
+            model_path=model_path,
             n_ctx=1024,
             n_threads=int(os.getenv("N_THREADS", "2")),
-            n_gpu_layers=int(os.getenv("N_GPU_LAYERS", "-1")),
+            n_gpu_layers=int(os.getenv("N_GPU_LAYERS", "0")),
             verbose=False,
         )
         print("[law-app] Modèle prêt.")
@@ -261,26 +286,50 @@ def evaluate_answer(question, answer, hint):
         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 format Qwen2.5
     prompt = (
-        f"Tu es un professeur de droit.\n"
+        "<|im_start|>system\n"
+        "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.\n"
+        "<|im_end|>\n"
+        "<|im_start|>user\n"
         f"Question : {question}\n"
-        f"Réponse : {answer}\n"
+        f"Réponse de l'étudiant : {answer}\n"
         f"Éléments attendus : {hint}\n\n"
-        "Réponds UNIQUEMENT avec ce JSON sur une ligne : "
-        '{"score": <0-10>, "feedback": "<commentaire bref en français>"}'
+        "Évalue cette réponse sur 10 et donne un commentaire bref en français.\n"
+        "Réponds UNIQUEMENT avec ce JSON sur une seule ligne, sans rien d'autre :\n"
+        '{"score": <entier 0-10>, "feedback": "<commentaire bref>"}\n'
+        "<|im_end|>\n"
+        "<|im_start|>assistant\n"
     )
     try:
-        out  = llm(prompt, max_tokens=150, temperature=0.1, stop=["###", "\n\n"])
+        out  = llm(
+            prompt,
+            max_tokens=150,
+            temperature=0.1,
+            stop=["<|im_end|>", "\n\n", "###"],
+        )
         text = out["choices"][0]["text"].strip()
-        data = json.loads(text[text.find("{"):text.rfind("}")+1])
+        print(f"[law-app] Réponse modèle : {text}")
+        # Extraire le JSON
+        start = text.find("{")
+        end   = text.rfind("}") + 1
+        if start == -1 or end == 0:
+            raise ValueError("Pas de JSON dans la réponse")
+        data  = json.loads(text[start:end])
         return max(0, min(10, int(data["score"]))), data.get("feedback", "")
     except Exception as e:
         print(f"[law-app] Erreur éval : {e}")
-        return 0, "Erreur d'évaluation, réessayez."
+        # Fallback mots-clés
+        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"(Erreur modèle – mots-clés : {hits}/{len(kw)})"
 
 # ── Handlers ─────────────────────────────────────���────────────────────────────
 def start_listening(ss):
-    state = S(ss)
+    state      = S(ss)
     lesson_idx = state.get("lesson_idx", 0)
     lesson     = LESSONS[lesson_idx]
     state.update({"phase": "listen", "listen_start": time.time(), "question_idx": None})
@@ -292,10 +341,10 @@ def start_listening(ss):
     )
     return (
         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(visible=True),
+        gr.update(visible=False),
+        gr.update(visible=False),
+        gr.update(visible=False),
         gr.update(interactive=False, value="⏳ Écoute en cours…"),
         D(state),
     )
@@ -304,7 +353,7 @@ def check_timer(ss):
     state = S(ss)
     if state["phase"] != "listen" or not state["listen_start"]:
         return gr.update(), "⚠️ Lancez d'abord l'écoute.", ss
-    rem = max(0, LISTEN_SECONDS - (time.time() - state["listen_start"]))
+    rem  = max(0, LISTEN_SECONDS - (time.time() - state["listen_start"]))
     m, s = divmod(int(rem), 60)
     if rem <= 0:
         return (
@@ -324,12 +373,12 @@ def open_quiz(ss):
     if elapsed < LISTEN_SECONDS:
         m, s = divmod(int(LISTEN_SECONDS - elapsed), 60)
         return (
-            gr.update(visible=True), gr.update(visible=False),
+            gr.update(visible=True),  gr.update(visible=False),
             gr.update(visible=False), gr.update(visible=False),
             f"⚠️ Patientez encore **{m} min {s:02d} s**.", "", "", ss,
         )
     lesson_idx = state.get("lesson_idx", 0)
-    idx = random.randrange(len(LESSONS[lesson_idx]["questions"]))
+    idx        = random.randrange(len(LESSONS[lesson_idx]["questions"]))
     state.update({"phase": "quiz", "question_idx": idx})
     return (
         gr.update(visible=False), gr.update(visible=True),
@@ -341,9 +390,11 @@ def submit_answer(answer, ss):
     state      = S(ss)
     lesson_idx = state.get("lesson_idx", 0)
     if state["phase"] != "quiz":
-        return (gr.update(visible=True), gr.update(visible=False),
-                gr.update(visible=False), gr.update(visible=False),
-                "", "", ss)
+        return (
+            gr.update(visible=True),  gr.update(visible=False),
+            gr.update(visible=False), gr.update(visible=False),
+            "", "➡️ Leçon suivante", ss,
+        )
     q         = LESSONS[lesson_idx]["questions"][state["question_idx"]]
     score, fb = evaluate_answer(q["q"], answer, q["hint"])
     total     = len(LESSONS)
@@ -358,14 +409,14 @@ def submit_answer(answer, ss):
         if is_last:
             next_label = "🏆 Voir mon certificat"
         else:
-            next_label = f"➡️ Leçon {lesson_idx + 2} — {LESSONS[lesson_idx + 1]['title'].split('—')[1].strip()}"
+            next_label = f"➡️ {LESSONS[lesson_idx + 1]['title']}"
     else:
         state["phase"] = "fail"
         result = (
             f"## ❌ Score insuffisant : {score}/10\n\n"
             f"**Commentaire :** {fb}\n\n"
             f"Seuil requis : **{PASS_SCORE}/10**. "
-            f"Veuillez **réécouter la leçon** avant de retenter."
+            "Veuillez **réécouter la leçon** avant de retenter."
         )
         next_label = "🔄 Réécouter la leçon"
 
@@ -381,14 +432,11 @@ def handle_next(ss):
     total      = len(LESSONS)
 
     if state["phase"] == "fail":
-        # Réécouter la même leçon
         return start_listening(D(state))
 
-    # PASS
     if lesson_idx >= total - 1:
-        # Dernière leçon → certificat
         state["phase"] = "done"
-        cert_md = (
+        cert = (
             "# 🏆 Félicitations !\n\n"
             "Vous avez complété avec succès les **3 leçons** du cours de droit civil :\n\n"
             "✅ Leçon 1 — Sources du droit et hiérarchie des normes\n\n"
@@ -400,15 +448,14 @@ def handle_next(ss):
         )
         return (
             None, "",
-            gr.update(visible=False),   # listen_col
-            gr.update(visible=False),   # quiz_col
-            gr.update(visible=False),   # result_col
-            gr.update(visible=True),    # cert_col
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
             gr.update(interactive=False, value="✅ Terminé"),
             D(state),
         )
     else:
-        # Leçon suivante
         state["lesson_idx"] = lesson_idx + 1
         state["listen_start"] = None
         return start_listening(D(state))
@@ -428,7 +475,6 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
         elem_id="title",
     )
 
-    # ── Étape 1 : Écoute ──────────────────────────────────────────────────────
     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.")
@@ -439,26 +485,22 @@ 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)
 
-    # ── Étape 2 : Quiz ────────────────────────────────────────────────────────
     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")
 
-    # ── Étape 3 : Résultat ────────────────────────────────────────────────────
     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")
 
-    # ── Étape 4 : Certificat ─────────────────────────────────────────────────
     with gr.Column(visible=False) as cert_col:
-        cert_md      = gr.Markdown("")
-        restart_btn  = gr.Button("🔄 Recommencer depuis le début", variant="secondary")
+        cert_md     = gr.Markdown("")
+        restart_btn = gr.Button("🔄 Recommencer depuis le début", variant="secondary")
 
     # ── Câblage ───────────────────────────────────────────────────────────────
-    # Outputs communs à start_listening et handle_next (quand leçon suivante)
     LISTEN_OUT = [audio_out, listen_msg,
                   listen_col, quiz_col, result_col, cert_col,
                   quiz_btn, session]
@@ -476,8 +518,10 @@ with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
     answer_box.submit(submit_answer, [answer_box, session], RES_OUT)
 
     next_btn.click(handle_next, [session], LISTEN_OUT)
-
     restart_btn.click(restart_from_cert, [session], LISTEN_OUT)
 
+# ── Préchargement du modèle au démarrage ──────────────────────────────────────
+threading.Thread(target=get_llm, daemon=True).start()
+
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)