fix(reclassement): la simulation montre tout ce que --force ecrira

Issus de la revue de la branche :

- `appliquer --dry-run` sans --force n'inscrivait pas dans
changements.csv les categories deja posees que le verdict contredit :
sur le corpus, ou toutes les lois en ont une, on relisait un fichier
presque vide avant un --force qui les reecrivait toutes. changements.csv
liste desormais toute loi dont la categorie changerait, avec sa suite
(appliquee, ou gardee faute de --force), et le README recommande
`--dry-run --force`.
- Une relance `--incertains` apres un arret sur quota repayait les lois
deja retentees avec un extrait : elle les saute.
- Une ligne de journal coupee par un arret brutal absorbait la ligne
suivante : le journal est termine par un saut de ligne avant d'ecrire.
- Le journal est indexe par l'identifiant de la loi : chaque verdict porte
desormais sa reference, et celui d'une autre loi (base reconstruite)
n'est ni repris ni applique.
- L'anomalie « Classement indisponible » posee par le pipeline est
effacee une fois la loi classee.
- Le commit toutes les 200 lois comptait les positions, et sautait
chaque fois que la 200e loi etait gardee ou a revoir : il compte les
lois ecrites.

Route /classifier/classify : un texte fait seulement de visas rendait
503 « reessayez plus tard », qu'aucun essai ne corrige ; il rend 422
(DocumentVide).

Comparaison sous Gemini : un budget epuise avant la premiere phrase leve
une erreur au lieu de rendre une reponse tronquee, et le second essai au
double n'avait pas lieu. GeminiBudgetEpuiseError le declenche.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app/api/routes/classifier.py

@@ -38,6 +38,7 @@ from app.models.user import User
 from app.services.legal_domain_classifier import (
     CANONICAL_DOMAINS,
     ClassementIndisponible,
+    DocumentVide,
     LegalDomainClassifier,
     get_legal_domain_classifier,
 )
@@ -130,6 +131,13 @@ async def classify_document(
         # await : l'appel synchrone bloquait la boucle d'evenements, donc
         # toutes les autres requetes, le temps de l'appel a Groq.
         result = await classifier.classify_async(request.title, request.text, request.doc_type)
+    except DocumentVide as exc:
+        # Un texte fait seulement de visas n'a pas d'objet a classer : la
+        # demande est en cause, et un « reessayez plus tard » serait faux.
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Rien à classer : ni titre, ni texte en dehors des visas.",
+        ) from exc
     except ClassementIndisponible as exc:
         logger.warning("Classement indisponible : %s", exc.raison)
         entetes = {}

app/services/comparison_service.py

@@ -52,6 +52,7 @@ from app.schemas.comparison import (
 from app.schemas.search import ChunkResult, SearchFilters, SearchRequest
 from app.services.article_reference import normalize_number
 from app.services.llm import (
+    ERREURS_BUDGET,
     ERREURS_LLM,
     ERREURS_QUOTA,
     ERREURS_SATURATION,
@@ -343,6 +344,10 @@ class ComparisonService:
             raise ComparisonQuotaError(str(e)) from e
         except ERREURS_SATURATION as e:
             raise ComparisonOverloadedError(str(e)) from e
+        except ERREURS_BUDGET:
+            # Gemini : la reflexion a pris tout le budget avant la grille. Le
+            # cas meme que le second essai, au double, est fait pour corriger.
+            return None
         except ERREURS_LLM as e:
             raise ComparisonError(str(e)) from e
 

app/services/gemini_service.py

@@ -111,6 +111,15 @@ class GeminiServiceError(Exception):
     pass
 
 
+class GeminiBudgetEpuiseError(GeminiServiceError):
+    """
+    Budget de jetons epuise AVANT la premiere phrase (la reflexion l'a pris).
+
+    Nommee a part : un appelant qui peut augmenter le budget — la comparaison
+    redemande au double — doit la reconnaitre sans lire le message.
+    """
+
+
 class GeminiQuotaError(GeminiServiceError):
     """
     Quota du fournisseur epuise (429).
@@ -308,7 +317,7 @@ FORBIDDEN:
             finish = _finish_reason(response)
             logger.warning(f"⚠️ Reponse vide de Gemini (finish_reason={finish})")
             if finish == "MAX_TOKENS":
-                raise GeminiServiceError(
+                raise GeminiBudgetEpuiseError(
                     "Reponse tronquee : le budget de jetons a ete epuise avant "
                     "la premiere phrase."
                 )

app/services/legal_domain_classifier.py

@@ -154,6 +154,13 @@ class ClassementIndisponible(Exception):
         self.quota = quota
 
 
+class DocumentVide(ClassementIndisponible):
+    """
+    Rien a classer : ni titre, ni texte une fois les visas retires. Une erreur
+    de la DEMANDE, qu'aucun nouvel essai ne corrigera (422, pas 503).
+    """
+
+
 @dataclass(frozen=True)
 class DomainResult:
     """
@@ -434,7 +441,7 @@ class LegalDomainClassifier:
         titre = (title or "").strip()
         extrait = extrait_pour_classement(content)
         if not titre and not extrait:
-            raise ClassementIndisponible("document vide : ni titre ni contenu")
+            raise DocumentVide("document vide : ni titre, ni texte hors des visas")
         return DocumentAClasser(titre=titre, extrait=extrait, type_acte=doc_type or None)
 
     def classify(

scripts/maintenance/reclassify_domains.py

@@ -28,8 +28,9 @@ Usage:
     python scripts/maintenance/reclassify_domains.py classer --extrait 0 --lot 40
     # 2. Les incertains, avec l'article premier, 15 par requete
     python scripts/maintenance/reclassify_domains.py classer --incertains --extrait 500 --lot 15
-    # 3. Relire le rapport, changements.csv et a_revoir.csv
-    python scripts/maintenance/reclassify_domains.py appliquer --dry-run
+    # 3. Simuler EXACTEMENT ce que fera l'etape 4, puis relire le rapport,
+    #    changements.csv et a_revoir.csv
+    python scripts/maintenance/reclassify_domains.py appliquer --dry-run --force
     # 4. Ecrire en base, categories existantes comprises
     python scripts/maintenance/reclassify_domains.py appliquer --force
 """
@@ -109,6 +110,16 @@ def _incertain(verdict: dict, seuil: float) -> bool:
     return verdict.get("statut") != "ok" or float(verdict.get("confiance") or 0) < seuil
 
 
+def _meme_loi(verdict: dict, loi: Law) -> bool:
+    """
+    Le verdict designe-t-il bien CETTE loi ? Le journal est indexe par
+    l'identifiant, qui change si la base est reconstruite ; la reference, non.
+    Une ligne d'avant ce controle (sans reference) est crue sur parole.
+    """
+    reference = verdict.get("reference")
+    return reference is None or reference == loi.reference
+
+
 # ==================== CLASSER ====================
 
 
@@ -118,6 +129,7 @@ def lois_a_classer(
     *,
     incertains: bool = False,
     seuil: float = 0.6,
+    longueur_extrait: int = 0,
     law_ids: Optional[Sequence[int]] = None,
     limite: Optional[int] = None,
 ) -> List[Law]:
@@ -126,13 +138,18 @@ def lois_a_classer(
 
     Par defaut : celles sans verdict « ok » obtenu avec les consignes
     actuelles. Avec `incertains` : celles dont le dernier verdict est « a
-    revoir » ou sous le seuil, a redemander avec un extrait.
+    revoir » ou sous le seuil, a redemander avec un extrait — sauf si ce
+    verdict a deja ete obtenu avec un extrait au moins aussi long : apres un
+    arret sur quota, la relance ne repaie pas les lois deja retentees.
+
+    Un verdict d'une AUTRE loi (meme identifiant, autre reference : base
+    reconstruite, autre base) compte comme absent.
     """
     # Sans le contenu : 2 226 textes integraux en memoire pour lire des titres.
     # Il n'est charge, loi par loi, que pour l'extrait de repli (extrait_de).
     requete = (
         session.query(Law)
-        .options(load_only(Law.id, Law.title, Law.type, Law.status))
+        .options(load_only(Law.id, Law.reference, Law.title, Law.type, Law.status))
         .filter(Law.status == "published")
         .order_by(Law.id)
     )
@@ -141,8 +158,14 @@ def lois_a_classer(
     lois = []
     for loi in requete:
         verdict = verdicts.get(loi.id)
+        if verdict is not None and not _meme_loi(verdict, loi):
+            verdict = None
         if incertains:
-            garder = verdict is not None and _incertain(verdict, seuil)
+            garder = (
+                verdict is not None
+                and _incertain(verdict, seuil)
+                and int(verdict.get("extrait") or 0) < max(1, longueur_extrait)
+            )
         else:
             garder = (
                 verdict is None
@@ -170,6 +193,21 @@ def extrait_de(session, loi: Law, longueur: int) -> str:
     return extrait_pour_classement(premier or loi.content, longueur)
 
 
+def _terminer_la_derniere_ligne(journal: Path) -> None:
+    """
+    Un arret brutal peut laisser une ligne coupee, sans saut de ligne : la
+    suivante s'y collerait, et les deux seraient perdues a la relecture.
+    """
+    if not journal.exists() or journal.stat().st_size == 0:
+        return
+    with journal.open("rb") as fichier:
+        fichier.seek(-1, 2)
+        if fichier.read(1) == b"\n":
+            return
+    with journal.open("a", encoding="utf-8") as fichier:
+        fichier.write("\n")
+
+
 def _horodatage() -> str:
     return datetime.now(timezone.utc).isoformat(timespec="seconds")
 
@@ -196,7 +234,8 @@ def classer(
     """Classe par lots et ajoute les verdicts au journal. Rend le code de sortie."""
     lois = lois_a_classer(
         session, charger_verdicts(journal),
-        incertains=incertains, seuil=seuil, law_ids=law_ids, limite=limite,
+        incertains=incertains, seuil=seuil, longueur_extrait=longueur_extrait,
+        law_ids=law_ids, limite=limite,
     )
     lots = [lois[i:i + taille_lot] for i in range(0, len(lois), taille_lot)]
     logger.info(
@@ -204,6 +243,7 @@ def classer(
         len(lois), len(lots), taille_lot, classifieur.modele, longueur_extrait,
     )
     journal.parent.mkdir(parents=True, exist_ok=True)
+    _terminer_la_derniere_ligne(journal)
     jetons_total = requetes_total = 0
     debut = time.time()
 
@@ -243,6 +283,7 @@ def classer(
             for loi, verdict in zip(lot, resultat.verdicts):
                 ligne = {
                     "law_id": loi.id,
+                    "reference": loi.reference,
                     "titre": (loi.title or "")[:200],
                     "statut": "ok" if verdict else "a_revoir",
                     "domaine": verdict.domain if verdict else None,
@@ -294,7 +335,12 @@ def appliquer(
     """
     Ecrit les verdicts « ok » au-dessus du seuil. Sans `force`, une loi qui a
     deja une autre categorie la garde (choix d'un administrateur, peut-etre).
-    Ecrit changements.csv et a_revoir.csv dans tous les cas.
+
+    Ecrit changements.csv et a_revoir.csv dans tous les cas. changements.csv
+    liste TOUTE loi dont le verdict differe de la categorie actuelle, avec ce
+    qui lui arrive (`suite`) : appliquee, ou gardee faute de --force. Une
+    simulation sans --force ne montrait pas les categories qu'un --force
+    allait remplacer — precisement celles qu'il faut relire.
     """
     carte = load_domain_map(session)
     noms = {identifiant: nom for nom, identifiant in session.query(Category.name, Category.id)}
@@ -304,18 +350,22 @@ def appliquer(
         session.query(Law)
         .options(load_only(
             Law.id, Law.reference, Law.title, Law.category_id,
-            Law.category_confidence, Law.suggested_categories,
+            Law.category_confidence, Law.suggested_categories, Law.processing_error,
         ))
         .filter(Law.id.in_(list(verdicts)))
         .order_by(Law.id)
         .all()
     )
 
-    for position, loi in enumerate(lois, start=1):
+    ecrites = 0
+    for loi in lois:
         verdict = verdicts[loi.id]
         actuelle = noms.get(loi.category_id, "(aucune)")
         bilan.avant[actuelle] += 1
         cible = carte.get((verdict.get("domaine") or "").lower())
+        if not _meme_loi(verdict, loi):
+            # Le verdict d'une autre loi : base reconstruite depuis le classement.
+            verdict = {**verdict, "statut": "autre_loi"}
 
         if _incertain(verdict, seuil) or cible is None:
             bilan.a_revoir += 1
@@ -330,6 +380,10 @@ def appliquer(
         if loi.category_id not in (None, cible) and not force:
             bilan.protegees += 1
             bilan.apres[actuelle] += 1
+            changements.append([
+                loi.id, loi.reference, loi.title, actuelle, verdict["domaine"],
+                verdict["confiance"], "gardee (--force pour appliquer)",
+            ])
             continue
 
         bilan.appliquees += 1
@@ -337,7 +391,8 @@ def appliquer(
         if loi.category_id != cible:
             bilan.changees += 1
             changements.append([
-                loi.id, loi.reference, loi.title, actuelle, verdict["domaine"], verdict["confiance"],
+                loi.id, loi.reference, loi.title, actuelle, verdict["domaine"],
+                verdict["confiance"], "appliquee",
             ])
         if not dry_run:
             secondaires = [carte[nom.lower()] for nom in verdict.get("secondaires") or []
@@ -345,7 +400,11 @@ def appliquer(
             loi.category_id = cible
             loi.category_confidence = float(verdict["confiance"])
             loi.suggested_categories = [cible, *[s for s in secondaires if s != cible]]
-            if position % LOIS_PAR_COMMIT == 0:
+            loi.processing_error = _sans_anomalie_de_classement(loi.processing_error)
+            ecrites += 1
+            # Compte les lois ECRITES : compter les positions sautait le commit
+            # chaque fois que la 200e loi etait gardee ou a revoir.
+            if ecrites % LOIS_PAR_COMMIT == 0:
                 session.commit()
 
     if not dry_run:
@@ -354,7 +413,7 @@ def appliquer(
     dossier.mkdir(parents=True, exist_ok=True)
     _ecrire_csv(
         dossier / "changements.csv",
-        ["law_id", "reference", "titre", "avant", "apres", "confiance"], changements,
+        ["law_id", "reference", "titre", "avant", "apres", "confiance", "suite"], changements,
     )
     _ecrire_csv(
         dossier / "a_revoir.csv",
@@ -364,6 +423,22 @@ def appliquer(
     return bilan
 
 
+# Prefixe de l'anomalie que le pipeline pose quand le classement est
+# indisponible (app/tasks/process_law.py). Elle n'a plus lieu d'etre une fois
+# la loi classee ; les autres anomalies (pages illisibles, vecteurs) restent.
+_ANOMALIE_DE_CLASSEMENT = "Classement indisponible"
+
+
+def _sans_anomalie_de_classement(erreur: Optional[str]) -> Optional[str]:
+    if not erreur:
+        return erreur
+    restes = [
+        morceau for morceau in erreur.split(" | ")
+        if not morceau.startswith(_ANOMALIE_DE_CLASSEMENT)
+    ]
+    return " | ".join(restes) or None
+
+
 def _ecrire_csv(chemin: Path, entete: List[str], lignes: List[list]) -> None:
     with chemin.open("w", encoding="utf-8", newline="") as sortie:
         ecrivain = csv.writer(sortie)
@@ -378,7 +453,8 @@ def _rapport(bilan: Bilan, dossier: Path, dry_run: bool) -> None:
             logger.info("%-55s %7d %7d", nom[:55], bilan.avant[nom], bilan.apres[nom])
     logger.info(
         "%s : %d verdicts appliques dont %d changements de categorie, %d categories "
-        "existantes gardees (--force pour les remplacer), %d a revoir",
+        "existantes gardees (--force pour les remplacer ; elles figurent dans "
+        "changements.csv), %d a revoir",
         "SIMULATION, rien n'est ecrit" if dry_run else "Ecrit en base",
         bilan.appliquees, bilan.changees, bilan.protegees, bilan.a_revoir,
     )

tests/test_api/test_classifier_routes.py

@@ -110,6 +110,18 @@ class TestClassify:
         assert response.status_code == 422
         assert classeur.titres == []
 
+    async def test_texte_reduit_aux_visas_rend_422(self, admin_client: AsyncClient, classeur):
+        """Une erreur de la demande, qu'un nouvel essai ne corrigera pas : pas de 503."""
+        from app.services.legal_domain_classifier import DocumentVide
+
+        classeur.erreur = DocumentVide("document vide")
+
+        response = await admin_client.post(
+            URL, json={"title": "", "text": "Vu la Constitution ;\nVu le décret n°2011/408 ;"}
+        )
+
+        assert response.status_code == 422
+
     async def test_classement_indisponible_rend_503(self, admin_client: AsyncClient, classeur):
         """Jamais de domaine invente : l'ancien code rendait Droit Administratif."""
         classeur.erreur = ClassementIndisponible("quota Groq", retry_after=41.2, quota=True)

tests/test_scripts/test_reclassify_domains.py

@@ -177,6 +177,39 @@ class TestClasser:
         assert derniers[lois[1]]["domaine"] == FINANCES
         assert derniers[lois[1]]["extrait"] == 500
 
+        # Relance apres un arret : la loi 3, encore « a revoir » mais deja
+        # retentee avec un extrait, n'est pas repayee.
+        troisieme = _Classeur()
+        script.classer(
+            session, troisieme, journal=journal, taille_lot=15,
+            longueur_extrait=500, incertains=True,
+        )
+        assert troisieme.lots == []
+
+    def test_une_ligne_coupee_n_absorbe_pas_la_suivante(self, base, tmp_path):
+        session, ids, lois = base
+        journal = tmp_path / "verdicts.jsonl"
+        journal.write_text('{"law_id": 999, "titre": "Déc', encoding="utf-8")
+
+        script.classer(session, _Classeur([(FINANCES, 0.9)] * 5), journal=journal, taille_lot=5)
+
+        assert set(script.charger_verdicts(journal)) == set(lois)
+
+    def test_le_verdict_d_une_autre_loi_ne_compte_pas(self, base, tmp_path):
+        """Base reconstruite : l'identifiant 1 designe maintenant une autre loi."""
+        session, ids, lois = base
+        journal = tmp_path / "verdicts.jsonl"
+        journal.write_text(json.dumps({
+            "law_id": lois[0], "reference": "AUTRE-LOI", "statut": "ok",
+            "domaine": FINANCES, "confiance": 0.9, "consignes": script.VERSION_DES_CONSIGNES,
+        }) + "\n", encoding="utf-8")
+        classeur = _Classeur([(FINANCES, 0.9)] * 5)
+
+        script.classer(session, classeur, journal=journal, taille_lot=5)
+
+        assert len(classeur.lots[0]) == 5
+        assert script.charger_verdicts(journal)[lois[0]]["reference"] == "R-1"
+
 
 def _verdicts(lois, *domaines):
     """{law_id: verdict} : (domaine, confiance) ou None pour « a revoir »."""
@@ -209,6 +242,68 @@ class TestAppliquer:
             FINANCES, FONCTION_PUBLIQUE,
         ]
 
+    def test_la_simulation_sans_force_montre_les_categories_qu_il_remplacera(self, base, tmp_path):
+        """
+        Le cas du corpus : toutes les lois ont deja une categorie. Une
+        simulation qui n'en listait aucune laissait relire un fichier vide
+        avant un --force qui les reecrivait toutes.
+        """
+        session, ids, lois = base
+        verdicts = _verdicts(lois, (FINANCES, 0.9))
+
+        bilan = script.appliquer(session, verdicts, dossier=tmp_path, dry_run=True)
+
+        assert bilan.protegees == 1
+        lignes = _csv(tmp_path / "changements.csv")
+        assert [(ligne["apres"], ligne["suite"]) for ligne in lignes] == [
+            (FINANCES, "gardee (--force pour appliquer)"),
+        ]
+
+    def test_l_anomalie_de_classement_est_effacee(self, base, tmp_path):
+        session, ids, lois = base
+        session.execute(text("UPDATE laws SET processing_error = :e WHERE id = :id"), {
+            "id": lois[0],
+            "e": "page 3 illisible | Classement indisponible (quota Groq) : relancer "
+                 "scripts/maintenance/reclassify_domains.py",
+        })
+        session.execute(text("UPDATE laws SET processing_error = :e WHERE id = :id"), {
+            "id": lois[1], "e": "Classement indisponible (panne) : relancer ...",
+        })
+        session.commit()
+
+        script.appliquer(
+            session, _verdicts(lois, (FINANCES, 0.9), (FINANCES, 0.9)), dossier=tmp_path, force=True
+        )
+
+        session.expire_all()
+        assert session.get(Law, lois[0]).processing_error == "page 3 illisible"
+        assert session.get(Law, lois[1]).processing_error is None
+
+    def test_commit_toutes_les_n_lois_ecrites(self, base, tmp_path, monkeypatch):
+        """Compter les positions sautait le commit quand la n-ieme loi etait a revoir."""
+        session, ids, lois = base
+        monkeypatch.setattr(script, "LOIS_PAR_COMMIT", 2)
+        commits = []
+        vrai_commit = session.commit
+        monkeypatch.setattr(session, "commit", lambda: (commits.append(1), vrai_commit()))
+        verdicts = _verdicts(lois, (FINANCES, 0.9), None, (FINANCES, 0.9), None, (FINANCES, 0.9))
+
+        script.appliquer(session, verdicts, dossier=tmp_path, force=True)
+
+        # 3 lois ecrites : un commit a la 2e, puis le commit final.
+        assert len(commits) == 2
+
+    def test_le_verdict_d_une_autre_loi_n_est_pas_applique(self, base, tmp_path):
+        session, ids, lois = base
+        verdicts = _verdicts(lois, (FINANCES, 0.9))
+        verdicts[lois[0]]["reference"] = "AUTRE-LOI"
+
+        bilan = script.appliquer(session, verdicts, dossier=tmp_path, force=True)
+
+        session.expire_all()
+        assert bilan.a_revoir == 1
+        assert session.get(Law, lois[0]).category_id == ids[ADMINISTRATIF]
+
     def test_force_applique_categorie_confiance_et_suggestions(self, base, tmp_path):
         session, ids, lois = base
         verdicts = _verdicts(lois, (FINANCES, 0.9))

tests/test_services/test_comparison_service.py

@@ -579,6 +579,23 @@ class TestEchecs:
         budgets = [appel.kwargs["max_tokens"] for appel in llm.generate.await_args_list]
         assert budgets == [COMPARISON_MAX_TOKENS, COMPARISON_MAX_TOKENS_SECOND_ESSAI]
 
+    async def test_budget_epuise_avant_la_grille_redemande_au_double(
+        self, db_session, code_minier, llm
+    ):
+        """Gemini leve une erreur, sans texte, quand la reflexion prend tout le budget."""
+        from app.services.gemini_service import GeminiBudgetEpuiseError
+
+        llm.generate.side_effect = [
+            GeminiBudgetEpuiseError("budget epuise avant la premiere phrase"),
+            {"response": _grille(CRITERES_PAR_DEFAUT)},
+        ]
+        service = ComparisonService(db_session, llm=llm)
+
+        resultat = await service.compare("permis de recherche", "permis d'exploitation")
+
+        assert len(resultat.rows) == len(CRITERES_PAR_DEFAUT)
+        assert llm.generate.await_args.kwargs["max_tokens"] == COMPARISON_MAX_TOKENS_SECOND_ESSAI
+
     async def test_grille_coupee_redemandee_au_double(self, db_session, code_minier, llm):
         llm.generate.side_effect = [
             {"response": '{"lignes": [{"index": 0', "tronquee": True},

tests/test_services/test_legal_domain_classifier.py

@@ -37,6 +37,7 @@ from app.services.legal_domain_classifier import (
     SANTE,
     ClassementIndisponible,
     DocumentAClasser,
+    DocumentVide,
     LegalDomainClassifier,
     extrait_pour_classement,
     get_legal_domain_classifier,
@@ -303,10 +304,18 @@ class TestUnDocument:
     def test_document_vide(self):
         classifieur, faux = classeur()
 
-        with pytest.raises(ClassementIndisponible):
+        with pytest.raises(DocumentVide):
             classifieur.classify("", "   ")
         assert faux.appels == []
 
+    def test_texte_reduit_aux_visas_est_vide(self):
+        """Les visas sont retires de l'extrait : il ne reste rien a classer."""
+        classifieur, faux = classeur()
+
+        with pytest.raises(DocumentVide):
+            classifieur.classify("", "Vu la Constitution ;\nVu le décret n°2011/408 ;")
+        assert faux.appels == []
+
     def test_aucun_verdict(self):
         classifieur, faux = classeur(verdicts(), verdicts())