Update app.py

app.py

@@ -1,639 +1,305 @@
 
 """
-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.
+DroitPro – Application d'apprentissage du droit procédural pénal
+Évaluation des réponses par Gemma-4 via le serveur formegemma (llama-server OpenAI-compatible)
 """
-import os, json, time, tempfile, random, threading, glob
-import sys
-try:
-    import pyaudioop
-    sys.modules["audioop"] = pyaudioop
-except ImportError:
-    pass
- 
+
+import json
+import threading
+import time
+import requests
 import gradio as gr
- 
-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
- 
-try:
-    from llama_cpp import Llama
-    _LLAMA_AVAILABLE = True
-except ImportError:
-    _LLAMA_AVAILABLE = False
- 
-from gtts import gTTS
-from huggingface_hub import hf_hub_download
- 
-try:
-    from llama_cpp import Llama
-    _LLAMA_OK = True
-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_AVAILABLE:
-        return None
-    with _llm_lock:
-        if _llm is not None:
-            return _llm
-        gguf_files = glob.glob("/app/*.gguf") + glob.glob("*.gguf")
-        if not gguf_files:
-            print("[spelling-app] No .gguf file found – AI tips disabled.")
-            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)
-        print("[spelling-app] Model ready.")
-        return _llm
- 
-# ── Leçons ────────────────────────────────────────────────────────────────────
-LESSONS = [
-    {
-        "title": "Leçon 1 — Les principes directeurs et la preuve pénale",
-        "text": """
-Cours de procédure pénale. Les principes du procès pénal et la preuve.
-Première partie : Le droit à un procès équitable.
-Consacré par l'article préliminaire du Code de procédure pénale et l'article 6 de la
-Convention européenne des droits de l'homme (CEDH), le droit à un procès équitable
-irrigue l'ensemble de la matière. Il implique l'accès à un tribunal indépendant et
-impartial, le respect du délai raisonnable, et la garantie des droits de la défense
-(égalité des armes, principe du contradictoire).
- 
-Deuxième partie : La charge de la preuve et la présomption d'innocence.
-La preuve incombe au ministère public (la partie poursuivante), qui doit renverser
-la présomption d'innocence dont bénéficie toute personne suspectée ou poursuivie.
-Le doute doit toujours profiter à l'accusé (in dubio pro reo). Des présomptions de
-culpabilité exceptionnelles existent (ex: infractions douanières), mais elles doivent
-rester réfragables (pouvoir être renversées par la défense) et proportionnées.
- 
-Troisième partie : Le principe de l'intime conviction et la liberté de la preuve.
-En vertu de l'article 427 du Code de procédure pénale, hors les cas où la loi en dispose
-autrement, les infractions peuvent être établies par tout mode de preuve et le juge
-décide d'après son intime conviction. Le juge ne peut fonder sa décision que sur des
-preuves qui lui sont apportées au cours des débats et contradictoirement discutées.
- 
-Quatrième partie : La loyauté de la preuve.
-Les autorités publiques (policiers, magistrats) sont soumises à un devoir de loyauté.
-La provocation policière à l'infraction est strictement interdite car elle vicie la
-procédure. En revanche, la jurisprudence tolère la simple provocation à la preuve,
-à condition qu'elle ne constitue pas un stratagème actif poussant l'individu à
-s'auto-incriminer (ex: sonorisation déloyale de cellules de garde à vue censurée
-par l'Assemblée plénière de la Cour de cassation le 6 mars 2015). À l'inverse,
-les preuves apportées par des particuliers, même obtenues de façon illicite, sont
-recevables et soumises au débat contradictoire.
-""",
-        "questions": [
-            {"q": "Quels textes fondamentaux garantissent le droit à un procès équitable en droit français ?",
-             "hint": "Article préliminaire du Code de procédure pénale, Article 6 de la CEDH"},
-            {"q": "Quelle est la différence entre la provocation à l'infraction et la provocation à la preuve ?",
-             "hint": "La provocation à l'infraction (création de l'infraction par la police) est interdite, la provocation à la preuve est tolérée sous conditions (absence de stratagème déloyal). Pensez à l'auto-incrimination."},
-            {"q": "Que signifie le principe de l'intime conviction (Article 427 du CPP) ?",
-             "hint": "Liberté de la preuve, le juge évalue librement la valeur des preuves débattues contradictoirement à l'audience."},
-        ],
-    },
-    {
-        "title": "Leçon 2 — La police judiciaire, l'enquête et la garde à vue",
-        "text": """
-Cours de procédure pénale. Les acteurs de l'enquête et les mesures de contrainte.
-Première partie : Les organes de la police judiciaire (PJ).
-La police judiciaire est chargée de constater les infractions, d'en rassembler les
-preuves et d'en chercher les auteurs. Elle agit sous la direction du procureur de la
-République et le contrôle de la chambre de l'instruction. Il faut distinguer les
-Officiers de Police Judiciaire (OPJ), qui ont des pouvoirs étendus (décider d'une
-garde à vue, mener des perquisitions), des Agents de Police Judiciaire (APJ) qui
-les secondent.
- 
-Deuxième partie : Les cadres d'enquête.
-L'enquête de flagrance s'applique aux crimes et délits qui se commettent ou viennent
-de se commettre. En raison de l'urgence, la police dispose de pouvoirs coercitifs
-importants (perquisitions sans assentiment). Elle dure 8 jours (prolongeable 8 jours).
-L'enquête préliminaire intervient en l'absence de flagrance. Elle est en principe non
-coercitive (ex: perquisition avec assentiment exprès), sauf autorisation spéciale du
-Juge des libertés et de la détention (JLD) pour les infractions les plus graves.
- 
-Troisième partie : La garde à vue.
-Réformée en profondeur par la loi du 14 avril 2011 à la suite de condamnations par la
-CEDH, la garde à vue est une mesure de contrainte décidée par un OPJ. Elle suppose des
-raisons plausibles de soupçonner qu'une personne a commis ou tenté de commettre un crime
-ou un délit puni d'une peine d'emprisonnement. Sa durée initiale est de 24h,
-renouvelable sous contrôle du procureur, voire prolongeable jusqu'à 96h (terrorisme,
-criminalité organisée) ou 144h par un magistrat.
-Dès le début de la mesure, le suspect bénéficie de droits fondamentaux : droit au
-silence, droit de faire prévenir un proche, examen médical, et surtout droit à
-l'assistance d'un avocat lors des auditions et confrontations.
-""",
-        "questions": [
-            {"q": "Quelle différence majeure existe-t-il entre un OPJ et un APJ ?",
-             "hint": "L'OPJ (Officier) a le pouvoir de prendre des mesures coercitives comme le placement en garde à vue, l'APJ (Agent) le seconde."},
-            {"q": "Qu'est-ce qui caractérise l'enquête de flagrance par rapport à l'enquête préliminaire ?",
-             "hint": "Infraction qui se commet ou vient de se commettre. Pouvoirs coercitifs immédiats de la police sans avoir besoin du consentement de la personne."},
-            {"q": "Quels sont les droits notifiés à un suspect dès son placement en garde à vue ?",
-             "hint": "Droit au silence, assistance d'un avocat dès la première heure, examen médical, information d'un proche."},
-        ],
-    },
-    {
-        "title": "Leçon 3 — L'action publique, l'action civile et la prescription",
-        "text": """
-Cours de procédure pénale. Les actions nées de l'infraction.
-Première partie : L'action publique et l'action civile.
-Toute infraction donne naissance à deux actions. L'action publique vise à l'application
-d'une peine pour réparer le trouble à l'ordre social. Elle est exercée par le Ministère
-public (le Parquet, magistrats soumis à une hiérarchie).
-L'action civile vise la réparation du préjudice privé causé par l'infraction. Elle est
-exercée par la victime. La victime peut déclencher l'action publique en se constituant
-partie civile (saisine du juge d'instruction ou citation directe).
- 
-Deuxième partie : L'extinction de l'action publique et la prescription.
-L'action publique peut s'éteindre par le décès du mis en cause, l'amnistie, l'abrogation
-de la loi pénale, la chose jugée ou la prescription.
-La loi du 27 février 2017 a profondément réformé les délais de prescription de l'action
-publique, les allongeant à : 1 an pour les contraventions, 6 ans pour les délits, et
-20 ans pour les crimes (des délais plus longs existent pour le terrorisme ou les
-crimes sexuels sur mineurs).
- 
-Troisième partie : L'infraction occulte et dissimulée.
-La loi de 2017 a consacré la jurisprudence sur le point de départ de la prescription.
-Pour une infraction occulte (qui ne peut être connue en raison de ses éléments constitutifs)
-ou dissimulée (manœuvres de l'auteur pour empêcher sa découverte, ex: abus de biens sociaux),
-le délai de prescription ne court qu'à partir du jour où l'infraction a pu être constatée.
-Cependant, la loi a fixé un "délai butoir" : l'action publique ne peut plus être engagée
-au-delà de 12 ans (délits) ou 30 ans (crimes) à compter de la commission des faits.
- 
-Quatrième partie : Les alternatives aux poursuites.
-En vertu de l'opportunité des poursuites, le procureur peut classer sans suite,
-poursuivre, ou proposer des mesures alternatives. La composition pénale permet de
-proposer une amende ou des mesures de réparation à une personne qui reconnait les faits.
-La Convention Judiciaire d'Intérêt Public (CJIP), créée par la loi Sapin II (2016),
-permet à une personne morale d'échapper à une condamnation pénale en payant une
-forte amende de conformité.
-""",
-        "questions": [
-            {"q": "Quels sont les délais de droit commun de la prescription de l'action publique depuis la loi de 2017 ?",
-             "hint": "1 an (contraventions), 6 ans (délits), 20 ans (crimes)."},
-            {"q": "Comment fonctionne la prescription pour une infraction occulte ou dissimulée ?",
-             "hint": "Le point de départ est reporté au jour où l'infraction est apparue/constatée, avec un délai butoir maximal de 12 ans ou 30 ans depuis les faits."},
-            {"q": "Quelles sont les finalités respectives de l'action publique et de l'action civile ?",
-             "hint": "Action publique = application d'une peine (trouble social) / Action civile = réparation du préjudice (dommages-intérêts)."},
-        ],
-    },
-    {
-        "title": "Leçon 4 — L'instruction préparatoire et les mesures de sûreté",
-        "text": """
-Cours de procédure pénale. L'instruction par le juge d'instruction.
-Première partie : Le rôle et la saisine du juge d'instruction.
-L'instruction préparatoire est obligatoire en matière de crime, facultative pour les
-délits. Elle est menée par le juge d'instruction, un magistrat du siège indépendant.
-Il instruit "à charge et à décharge" pour manifester la vérité.
-Il est saisi in rem (il ne peut enquêter que sur les faits visés par le réquisitoire
-du procureur ou la plainte de la victime). S'il découvre des faits nouveaux, il a
-besoin d'un réquisitoire supplétif.
- 
-Deuxième partie : Les statuts des personnes visées.
-Le juge peut placer une personne sous le statut de témoin assisté s'il existe de
-simples indices vraisemblables.
-Il ne peut prononcer une mise en examen que s'il existe des "indices graves ou concordants"
-rendant vraisemblable la participation aux faits. Le mis en examen dispose de droits
-larges (demandes d'actes, requêtes en nullité, avocat).
- 
-Troisième partie : La détention provisoire et le contrôle judiciaire.
-La liberté est le principe, la détention l'exception. Le juge d'instruction a perdu
-le pouvoir d'incarcérer depuis 2000. C'est le Juge des Libertés et de la Détention (JLD)
-qui peut prononcer la détention provisoire si le contrôle judiciaire (obligations à respecter,
-ex: interdiction de paraître) ou l'Assignation à Résidence sous Surveillance Électronique
-(ARSE) se révèlent insuffisants.
-La détention provisoire doit être strictement motivée (risque de fuite, protection
-des preuves, trouble à l'ordre public) et est limitée dans le temps.
- 
-Quatrième partie : La clôture de l'instruction.
-À la fin de ses investigations, le juge rend une ordonnance de règlement. Soit un
-non-lieu (charges insuffisantes), soit une ordonnance de renvoi (devant le tribunal
-correctionnel) ou de mise en accusation (devant la Cour d'assises). Les actes
-irréguliers accomplis pendant l'instruction peuvent être sanctionnés par la nullité,
-prononcée par la Chambre de l'instruction.
-""",
-        "questions": [
-            {"q": "Que signifie la règle de la saisine « in rem » du juge d'instruction ?",
-             "hint": "Le juge ne peut instruire que sur les faits expressément visés dans le réquisitoire du parquet ou la plainte. Il a besoin d'un réquisitoire supplétif pour des faits nouveaux."},
-            {"q": "Quelle est la condition posée par l'article 80-1 du CPP pour mettre une personne en examen ?",
-             "hint": "L'existence d'indices graves ou concordants de participation aux faits."},
-            {"q": "Quel magistrat est compétent pour placer une personne en détention provisoire au cours de l'instruction ?",
-             "hint": "Le Juge des libertés et de la détention (JLD), sur saisine du juge d'instruction ou du procureur."},
-        ],
-    },
-    {
-        "title": "Leçon 5 — Les juridictions de jugement et les voies de recours",
-        "text": """
-Cours de procédure pénale. Le procès pénal et les recours.
-Première partie : Les juridictions de droit commun.
-La compétence matérielle répartit les affaires selon la gravité :
-- Le Tribunal de police (juge unique) statue sur les contraventions.
-- Le Tribunal correctionnel (formation collégiale ou juge unique) juge les délits.
-- La Cour d'assises juge les crimes. Composée de 3 magistrats professionnels et
-d'un jury populaire (6 citoyens en premier ressort, 9 en appel). Les décisions sont
-prises à la majorité et depuis 2012, les arrêts d'assises doivent être motivés.
-Une expérimentation (Loi de programmation 2018-2022) a créé les Cours Criminelles
-Départementales pour juger les crimes punis de 15 à 20 ans de réclusion sans jury populaire.
- 
-Deuxième partie : Les modes de comparution (matière correctionnelle).
-Le Parquet peut opter pour plusieurs voies de poursuites rapides : la comparution
-immédiate (délits punis d'au moins 2 ans, ou 6 mois si flagrance), la Comparution
-sur Reconnaissance Préalable de Culpabilité (CRPC, ou "plaider-coupable",
-qui suppose l'accord du prévenu et l'homologation du juge), ou l'ordonnance pénale
-(procédure sans audience).
- 
-Troisième partie : Les voies de recours ordinaires.
-L'appel est une voie de réformation qui soumet l'affaire à la Cour d'appel
-(Chambre des appels correctionnels) ou à une cour d'assises d'appel. L'appel a un
-effet suspensif et dévolutif. Il interdit d'aggraver le sort de l'appelant s'il est
-seul à faire appel (prohibition de la reformatio in pejus).
-L'opposition permet de rétracter un jugement rendu par défaut (en l'absence du prévenu
-non informé). Le même tribunal rejuge l'affaire.
- 
-Quatrième partie : Les voies de recours extraordinaires.
-Le pourvoi en cassation est jugé par la Chambre criminelle de la Cour de cassation.
-Elle ne rejuge pas les faits, mais contrôle uniquement l'exacte application de la loi
-par les juges du fond.
-La demande en révision ou en réexamen (réformée en 2014) permet d'annuler une
-condamnation pénale définitive en cas de "fait nouveau" faisant naître un doute sur
-la culpabilité, ou suite à une condamnation de la France par la CEDH.
-""",
-        "questions": [
-            {"q": "Quelle est la composition de la Cour d'assises en premier ressort ?",
-             "hint": "3 magistrats professionnels (la cour) et un jury populaire composé de 6 citoyens (jurés)."},
-            {"q": "Qu'est-ce que la procédure de CRPC ?",
-             "hint": "Comparution sur Reconnaissance Préalable de Culpabilité. Un 'plaider-coupable' où le procureur propose une peine que le prévenu accepte, avant homologation par le juge du siège."},
-            {"q": "Le pourvoi en cassation représente-t-il un troisième degré de juridiction ?",
-             "hint": "Non. La Cour de cassation est juge du droit et non du fait. Elle contrôle l'application de la loi sans rejuger les faits."},
+
+# ─────────────────────────────────────────────
+# Configuration du serveur IA distant
+# ─────────────────────────────────────────────
+LLAMA_SERVER_URL = "https://ramedde-formegemma.hf.space/v1/chat/completions"
+
+SYSTEM_PROMPT = (
+    "Tu es un professeur expert en droit procédural pénal algérien et français. "
+    "Tu évalues les réponses des étudiants de manière pédagogique, bienveillante et précise. "
+    "Tu réponds UNIQUEMENT en français. "
+    "Tu bases tes évaluations sur les textes du Code de procédure pénale algérien et les principes généraux du droit pénal."
+)
+
+# ─────────────────────────────────────────────
+# Chargement des leçons
+# ─────────────────────────────────────────────
+with open("lessons.json", "r", encoding="utf-8") as f:
+    LESSONS = json.load(f)
+
+LESSON_MAP = {lesson["id"]: lesson for lesson in LESSONS}
+
+
+# ─────────────────────────────────────────────
+# Client IA – appel HTTP au serveur formegemma
+# ─────────────────────────────────────────────
+def call_model(user_prompt: str, timeout: int = 60) -> str:
+    """
+    Envoie un prompt au serveur llama-server (formegemma) via l'API OpenAI-compatible.
+    Retourne le texte généré ou un message d'erreur lisible.
+    """
+    payload = {
+        "model": "gemma",           # llama-server ignore ce champ, on le met par convention
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user",   "content": user_prompt},
         ],
+        "max_tokens": 600,
+        "temperature": 0.3,
+        "stream": False,
     }
-]
- 
-LISTEN_SECONDS = 10  # FIX: was 10 (dev value) — 900 = 15 min for production
-PASS_SCORE = 6
- 
-# ── Cache audio par leçon ─────────────────────────────────────────────────────
-_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:
-            text = LESSONS[lesson_idx]["text"]
-            tts = gTTS(text=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 json.dumps({"phase": "idle", "listen_start": None,
-                       "question_idx": None, "lesson_idx": 0})
- 
-def S(s): return json.loads(s)
-def D(d): return json.dumps(d)
- 
-# ── Évaluation ────────────────────────────────────────────────────────────────
-def evaluate_answer(question, answer, hint):
-    llm = get_llm()
-    if llm is None:
-        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 = (
-        """<|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 sur une seule ligne.\n\n"
- 
-        "# Exemples de comportement attendu :\n\n"
- 
-        "Question : Quelles sont les finalités respectives de l'action publique et de l'action civile ?\n"
-        "Réponse de l'étudiant : je ne sais pas\n"
-        "Éléments attendus : Action publique = application d'une peine (trouble social) / Action civile = réparation du préjudice (dommages-intérêts).\n"
-        "Assistant : {\"score\": 0, \"feedback\": \"Aucune réponse n'a été proposée. Pour rappel, l'action publique vise à sanctionner le trouble social par une peine, tandis que l'action civile cherche à réparer le préjudice subi.\"}\n\n"
- 
-        "Question : Quelles sont les finalités respectives de l'action publique et de l'action civile ?\n"
-        "Réponse de l'étudiant : lacion publique a pour but d'apication de pain laction civil a pour but domager le victime\n"
-        "Éléments attendus : Action publique = application d'une peine (trouble social) / Action civile = réparation du préjudice (dommages-intérêts).\n"
-        "Assistant : {\"score\": 7, \"feedback\": \"Les notions de peine et de dédommagement sont comprises, mais l'orthographe et la formulation doivent être grandement améliorées.\"}\n\n"
- 
-        "Question : Quel magistrat est compétent pour placer une personne en détention provisoire au cours de l'instruction ?\n"
-        "Réponse de l'étudiant : juge dinstrucion\n"
-        "Éléments attendus : Le Juge des libertés et de la détention (JLD), sur saisine du juge d'instruction ou du procureur..\n"
-        "Assistant : {\"score\": 2, \"feedback\": \"Le juge d'instruction saisit le dossier mais n'est pas compétent pour décider de la détention provisoire ; cette décision relève exclusivement du Juge des libertés et de la détention (JLD).\"}\n\n"
- 
-        "Question : Quelle différence majeure existe-t-il entre un OPJ et un APJ ?\n"
-        "Réponse de l'étudiant : l apj est t'une police administrative aopg police judiciare\n"
-        "Éléments attendus : L'OPJ (Officier) a le pouvoir de prendre des mesures coercitives comme le placement en garde à vue, l'APJ (Agent) le seconde.\n"
-        "Assistant : {\"score\": 1, \"feedback\": \"C'est incorrect. L'APJ et l'OPJ relèvent tous deux de la police judiciaire. La différence majeure réside dans les pouvoirs coercitifs (comme décider d'une garde à vue) réservés à l'OPJ, que l'APJ seconde.\"}\n"
-        "<|im_end|>\n"
-        "<|im_start|>user\n"
-        f"Question : {question}\n"
-        f"Réponse de l'étudiant : {answer}\n"
-        f"Éléments attendus : {hint}\n\n"
-        "É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=4000,
-            temperature=0.1,
-            stop=["<|im_end|>", "\n\n", "###"],
+        resp = requests.post(
+            LLAMA_SERVER_URL,
+            json=payload,
+            timeout=timeout,
+            headers={"Content-Type": "application/json"},
         )
-        text = out["choices"][0]["text"].strip()
-        print(f"[law-app] Réponse modèle : {text}")
-        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}")
-        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 – {e} mots-clés : {hits}/{len(kw)})"
- 
-# ── Handlers ──────────────────────────────────────────────────────────────────
-def start_listening(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})
-    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 (
-        audio, msg,
-        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),
-    )
- 
-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"]))
-    m, s = divmod(int(rem), 60)
-    if rem <= 0:
+        resp.raise_for_status()
+        data = resp.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+    except requests.exceptions.Timeout:
         return (
-            gr.update(interactive=True, value="✅ Accéder au Quiz"),
-            "✅ Durée atteinte ! Cliquez sur **Accéder au Quiz**.",
-            ss,
+            "⏳ Le serveur IA (formegemma) n'a pas répondu dans le délai imparti.\n"
+            "Il est peut-être en cours de démarrage (cold-start). "
+            "Veuillez réessayer dans 30 secondes."
         )
-    return (
-        gr.update(interactive=False, value=f"⏳ Encore {m:02d}:{s:02d}"),
-        f"🎧 Patientez encore **{m} min {s:02d} s**.",
-        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)
+    except requests.exceptions.ConnectionError:
         return (
-            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,
+            "🔌 Impossible de joindre le serveur IA (formegemma).\n"
+            "Vérifiez que l'espace ramedde/formegemma est bien actif sur Hugging Face."
         )
-    lesson_idx = state.get("lesson_idx", 0)
-    idx = random.randrange(len(LESSONS[lesson_idx]["questions"]))
-    state.update({"phase": "quiz", "question_idx": idx})
-    return (
-        gr.update(visible=False), gr.update(visible=True),
-        gr.update(visible=False), gr.update(visible=False),
-        "", LESSONS[lesson_idx]["questions"][idx]["q"], "", D(state),
-    )
- 
-# ── Submit avec désactivation immédiate du bouton ────────────────────────────
-def submit_answer(answer, ss):
-    state = S(ss)
-    lesson_idx = state.get("lesson_idx", 0)
- 
-    if state["phase"] != "quiz":
-        yield (
-            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),
-            gr.update(),   # next_btn — no change
-            ss,
+    except requests.exceptions.HTTPError as e:
+        code = e.response.status_code if e.response else "?"
+        if code == 503:
+            return (
+                "💤 Le serveur IA est en veille (503). "
+                "Ouvrez l'espace ramedde/formegemma pour le réveiller, puis réessayez."
+            )
+        return f"❌ Erreur HTTP {code} du serveur IA : {e}"
+    except Exception as e:
+        return f"❌ Erreur inattendue lors de l'appel au modèle : {e}"
+
+
+def warmup_server():
+    """Ping silencieux au démarrage pour réveiller formegemma en avance."""
+    time.sleep(3)
+    try:
+        requests.post(
+            LLAMA_SERVER_URL,
+            json={
+                "model": "gemma",
+                "messages": [{"role": "user", "content": "Bonjour."}],
+                "max_tokens": 5,
+            },
+            timeout=90,
         )
-        return
- 
-    # ── Étape 1 : désactiver immédiatement bouton + textbox ──────────────────
-    yield (
-        gr.update(visible=False), gr.update(visible=True),
-        gr.update(visible=False), gr.update(visible=False),
-        "",
-        gr.update(value="⏳ Réponse soumise — Correction en cours…", interactive=False),
-        gr.update(interactive=False),
-        gr.update(),   # next_btn — no change yet
-        ss,
+    except Exception:
+        pass   # échec silencieux, c'est juste un warmup
+
+
+# Lancer le warmup en arrière-plan sans bloquer le démarrage de Gradio
+threading.Thread(target=warmup_server, daemon=True).start()
+
+
+# ─────────────────────────────────────────────
+# Logique métier – évaluation
+# ─────────────────────────────────────────────
+def build_eval_prompt(question: str, reponse_modele: str, reponse_etudiant: str) -> str:
+    return f"""Voici une question de droit procédural pénal :
+
+QUESTION : {question}
+
+RÉPONSE MODÈLE (correcte et complète) :
+{reponse_modele}
+
+RÉPONSE DE L'ÉTUDIANT :
+{reponse_etudiant}
+
+Évalue la réponse de l'étudiant selon ces critères :
+1. Exactitude juridique (les éléments cités sont-ils corrects ?)
+2. Complétude (les points essentiels sont-ils abordés ?)
+3. Clarté et formulation
+
+Donne :
+- Une note sur 10
+- Les points forts de la réponse
+- Les lacunes ou erreurs à corriger
+- Un conseil d'amélioration
+
+Sois pédagogue et encourageant."""
+
+
+def evaluer_reponse(lesson_id: str, question_id: str, reponse_etudiant: str) -> str:
+    if not reponse_etudiant or not reponse_etudiant.strip():
+        return "⚠️ Veuillez saisir une réponse avant de demander l'évaluation."
+
+    lesson = LESSON_MAP.get(lesson_id)
+    if not lesson:
+        return "❌ Leçon introuvable."
+
+    question_obj = next(
+        (q for q in lesson["questions"] if q["id"] == question_id), None
     )
- 
-    # ── Étape 2 : évaluation IA ───────────────────────────────────────────────
-    q = LESSONS[lesson_idx]["questions"][state["question_idx"]]
-    score, fb = evaluate_answer(q["q"], answer, q["hint"])
-    total = len(LESSONS)
-    is_last = (lesson_idx >= total - 1)
- 
-    if score >= PASS_SCORE:
-        state["phase"] = "pass"
-        result = (
-            f"## 🎉 Bravo ! Leçon {lesson_idx + 1}/{total} réussie.\n\n"
-            f"**Score : {score}/10**\n\n**Commentaire :** {fb}"
-        )
-        # FIX: set the next_btn label correctly
-        next_label = "🏆 Voir mon certificat" if is_last else f"➡️ Leçon suivante : {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**. "
-            "Veuillez **réécouter la leçon** avant de retenter."
-        )
-        next_label = "🔄 Réécouter la leçon"
- 
-    # ── Étape 3 : afficher résultat ───────────────────────────────────────────
-    yield (
-        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),
-        gr.update(value=next_label),   # FIX: update next_btn label
-        D(state),
+    if not question_obj:
+        return "❌ Question introuvable."
+
+    prompt = build_eval_prompt(
+        question=question_obj["question"],
+        reponse_modele=question_obj["reponse_modele"],
+        reponse_etudiant=reponse_etudiant.strip(),
     )
- 
-def handle_next(ss):
-    state = S(ss)
-    lesson_idx = state.get("lesson_idx", 0)
-    total = len(LESSONS)
- 
-    if state["phase"] == "fail":
-        # Re-listen to same lesson — no cert_md change needed
-        return start_listening(D(state)) + (gr.update(),)
- 
-    if lesson_idx >= total - 1:
-        # ── FIX: cert_md was computed but NEVER sent to the UI ──────────────
-        state["phase"] = "done"
-        cert = (
-            "# 🏆 Félicitations !\n\n"
-            f"Vous avez complété avec succès les **{total} leçons** du cours de **procédure pénale** :\n\n"
-            + "".join(
-                f"✅ {LESSONS[i]['title']}\n\n" for i in range(total)
-            )
-            + "---\n\n"
-            "*Ce certificat atteste de votre participation et de votre réussite "
-            "aux évaluations du cours de procédure pénale.*"
-        )
-        return (
-            None, "",
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=True),    # cert_col
-            gr.update(interactive=False, value="✅ Terminé"),
-            D(state),
-            cert,                       # FIX: cert_md now receives its text
-        )
-    else:
-        state["lesson_idx"] = lesson_idx + 1
-        state["listen_start"] = None
-        return start_listening(D(state)) + (gr.update(),)
- 
-def restart_from_cert(ss):
-    return start_listening(fresh()) + (gr.update(),)
- 
-# ── 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())
- 
+    return call_model(prompt)
+
+
+# ─────────────────────────────────────────────
+# Interface Gradio
+# ─────────────────────────────────────────────
+CSS = """
+#header { text-align: center; margin-bottom: 1rem; }
+#lecon_box { background: #f0f4ff; border-radius: 8px; padding: 1rem; }
+#evaluation_box { border-left: 4px solid #4f6ef7; padding-left: 1rem; }
+.gr-button-primary { background: #4f6ef7 !important; }
+"""
+
+def get_lesson_choices():
+    return [(f"{l['id']} – {l['titre']}", l["id"]) for l in LESSONS]
+
+def get_question_choices(lesson_id: str):
+    lesson = LESSON_MAP.get(lesson_id)
+    if not lesson:
+        return []
+    return [(f"{q['id']} – {q['question'][:60]}…", q["id"]) for q in lesson["questions"]]
+
+def load_lesson_content(lesson_id: str) -> str:
+    lesson = LESSON_MAP.get(lesson_id)
+    if not lesson:
+        return ""
+    return lesson["contenu"]
+
+def load_question_text(lesson_id: str, question_id: str) -> str:
+    lesson = LESSON_MAP.get(lesson_id)
+    if not lesson:
+        return ""
+    q = next((q for q in lesson["questions"] if q["id"] == question_id), None)
+    return q["question"] if q else ""
+
+def on_lesson_change(lesson_id: str):
+    choices = get_question_choices(lesson_id)
+    first_qid = choices[0][1] if choices else None
+    content = load_lesson_content(lesson_id)
+    q_text = load_question_text(lesson_id, first_qid) if first_qid else ""
+    return (
+        gr.update(choices=choices, value=first_qid),
+        content,
+        q_text,
+        "",   # reset réponse étudiant
+        "",   # reset évaluation
+    )
+
+def on_question_change(lesson_id: str, question_id: str):
+    q_text = load_question_text(lesson_id, question_id)
+    return q_text, "", ""
+
+def on_evaluer(lesson_id, question_id, reponse):
+    result = evaluer_reponse(lesson_id, question_id, reponse)
+    return result
+
+def on_reset(lesson_id, question_id):
+    return "", ""
+
+
+with gr.Blocks(css=CSS, title="DroitPro – Droit Procédural Pénal") as demo:
+
     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",
+        "# ⚖️ DroitPro\n### Entraînement au droit procédural pénal – Évaluation par IA (Gemma 4)",
+        elem_id="header",
     )
- 
-    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" + str(_LLAMA_OK), 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("")   # FIX: this was never populated before
-        restart_btn = gr.Button("🔄 Recommencer depuis le début", variant="secondary")
- 
-    # ── Câblage ─────────────────────────────────────────────────────────────
-    LISTEN_OUT = [audio_out, listen_msg,
-                  listen_col, quiz_col, result_col, cert_col,
-                  quiz_btn, session]
- 
-    start_btn.click(start_listening, [session], LISTEN_OUT)
-    check_btn.click(check_timer, [session], [quiz_btn, timer_info, session])
- 
-    QUIZ_OUT = [listen_col, quiz_col, result_col, cert_col,
-                timer_info, question_md, answer_box, session]
-    quiz_btn.click(open_quiz, [session], QUIZ_OUT)
- 
-    # FIX: RES_OUT now includes next_btn so its label updates correctly
-    RES_OUT = [listen_col, quiz_col, result_col, cert_col,
-               result_md, submit_btn, answer_box, next_btn, session]
-    submit_btn.click(submit_answer, [answer_box, session], RES_OUT)
-    answer_box.submit(submit_answer, [answer_box, session], RES_OUT)
- 
-    # FIX: NEXT_OUT now includes cert_md so the certificate text is displayed
-    NEXT_OUT = [audio_out, listen_msg,
-                listen_col, quiz_col, result_col, cert_col,
-                quiz_btn, session, cert_md]
-    next_btn.click(handle_next, [session], NEXT_OUT)
-    restart_btn.click(restart_from_cert, [session], NEXT_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)
 
+    with gr.Row():
+        # ── Colonne gauche : navigation ──────────────────────────
+        with gr.Column(scale=1):
+            gr.Markdown("### 📚 Leçons")
+            lesson_dd = gr.Dropdown(
+                label="Choisir une leçon",
+                choices=get_lesson_choices(),
+                value=LESSONS[0]["id"],
+            )
+            gr.Markdown("### ❓ Questions")
+            question_dd = gr.Dropdown(
+                label="Choisir une question",
+                choices=get_question_choices(LESSONS[0]["id"]),
+                value=LESSONS[0]["questions"][0]["id"],
+            )
+
+        # ── Colonne droite : contenu + exercice ─────────────────
+        with gr.Column(scale=3):
+            with gr.Tab("📖 Leçon"):
+                lecon_text = gr.Textbox(
+                    label="Contenu de la leçon",
+                    value=LESSONS[0]["contenu"],
+                    lines=8,
+                    interactive=False,
+                    elem_id="lecon_box",
+                )
+
+            with gr.Tab("✏️ Exercice"):
+                question_text = gr.Textbox(
+                    label="Question",
+                    value=LESSONS[0]["questions"][0]["question"],
+                    lines=3,
+                    interactive=False,
+                )
+                reponse_input = gr.Textbox(
+                    label="Votre réponse",
+                    placeholder="Rédigez votre réponse ici...",
+                    lines=6,
+                )
+                with gr.Row():
+                    btn_evaluer = gr.Button("🔍 Évaluer ma réponse", variant="primary")
+                    btn_reset   = gr.Button("🔄 Effacer", variant="secondary")
+
+            with gr.Tab("📊 Évaluation IA"):
+                eval_output = gr.Textbox(
+                    label="Résultat de l'évaluation",
+                    lines=15,
+                    interactive=False,
+                    elem_id="evaluation_box",
+                    placeholder=(
+                        "L'évaluation de votre réponse apparaîtra ici après avoir cliqué "
+                        "sur « Évaluer ma réponse »."
+                    ),
+                )
+
+    # ── Événements ───────────────────────────────────────────────
+    lesson_dd.change(
+        fn=on_lesson_change,
+        inputs=[lesson_dd],
+        outputs=[question_dd, lecon_text, question_text, reponse_input, eval_output],
+    )
+
+    question_dd.change(
+        fn=on_question_change,
+        inputs=[lesson_dd, question_dd],
+        outputs=[question_text, reponse_input, eval_output],
+    )
+
+    btn_evaluer.click(
+        fn=on_evaluer,
+        inputs=[lesson_dd, question_dd, reponse_input],
+        outputs=[eval_output],
+    )
+
+    btn_reset.click(
+        fn=on_reset,
+        inputs=[lesson_dd, question_dd],
+        outputs=[reponse_input, eval_output],
+    )
+
+# ─────────────────────────────────────────────
+# Lancement
+# ─────────────────────────────────────────────
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)