Spaces:
Runtime error
Runtime error
Download scripts/maintenance/reclassify_domains.py from rahim237cm/jurix-api: direct link, hf CLI and curl.
- Browser
- Download file 20.9 kB
-
https://huggingface.co/spaces/rahim237cm/jurix-api/resolve/main/scripts/maintenance/reclassify_domains.py
- Command line
-
hf download hf://spaces/rahim237cm/jurix-api/scripts/maintenance/reclassify_domains.py
-
curl -L -o reclassify_domains.py https://huggingface.co/spaces/rahim237cm/jurix-api/resolve/main/scripts/maintenance/reclassify_domains.py
20.9 kB
| #!/usr/bin/env python3 | |
| """ | |
| Reclasse les lois dans les 14 domaines canoniques, par lots, en deux temps. | |
| 1. `classer` interroge Groq par lots et ECRIT LES VERDICTS dans un journal, | |
| data/reclassement/verdicts.jsonl. Rien n'est ecrit en base. Une relance | |
| saute les lois deja classees : une coupure ne coute que le lot en cours. | |
| Quota epuise : arret propre (code 4), avec l'heure de reprise. | |
| 2. `appliquer` lit le journal et ecrit categorie, confiance et suggestions. | |
| `--dry-run` n'ecrit RIEN en base, mais produit le rapport, changements.csv | |
| et a_revoir.csv : a relire avant d'appliquer pour de bon. | |
| POURQUOI DEUX TEMPS. Le palier gratuit de Groq (1 000 requetes et 200 000 | |
| jetons par jour et par modele) ne permet pas de tout classer d'une traite, ni | |
| de recommencer pour corriger une erreur d'application. Le journal garde ce | |
| qui a coute du quota ; l'application, elle, se rejoue a volonte. | |
| POURQUOI PAS DE DEFAUT. L'ancienne version rangeait en Droit Administratif | |
| (confiance 0,10) toute loi dont le classement echouait — 89 sur 122 pendant | |
| un essai, a cause des 429. Ici, une loi sans verdict exploitable, ou sous le | |
| seuil de confiance, n'est pas appliquee : elle part dans a_revoir.csv. | |
| Codes de sortie : 0 ; 2 configuration (domaines absents de la table, journal | |
| vide) ; 3 panne de Groq, relancer ; 4 quota epuise, relancer a l'heure dite. | |
| Usage: | |
| # 1. Titres seuls, 40 lois par requete (~56 requetes pour le corpus) | |
| 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. 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 | |
| """ | |
| import argparse | |
| import csv | |
| import json | |
| import logging | |
| import sys | |
| import time | |
| from collections import Counter | |
| from dataclasses import dataclass, field | |
| from datetime import datetime, timedelta, timezone | |
| from pathlib import Path | |
| from typing import Callable, Dict, List, Optional, Sequence | |
| RACINE = Path(__file__).resolve().parents[2] | |
| sys.path.insert(0, str(RACINE)) | |
| from sqlalchemy import text | |
| from sqlalchemy.orm import load_only | |
| from app.core.config import settings | |
| from app.core.database import SyncSessionLocal | |
| from app.models.law import Category, Law | |
| from app.services.category_resolver import load_domain_map | |
| from app.services.legal_domain_classifier import ( | |
| CANONICAL_DOMAINS, | |
| VERSION_DES_CONSIGNES, | |
| ClassementIndisponible, | |
| DocumentAClasser, | |
| LegalDomainClassifier, | |
| extrait_pour_classement, | |
| get_legal_domain_classifier, | |
| ) | |
| logger = logging.getLogger("reclassement") | |
| DOSSIER = RACINE / "data" / "reclassement" | |
| JOURNAL = DOSSIER / "verdicts.jsonl" | |
| SORTIE_CONFIGURATION = 2 | |
| SORTIE_PANNE = 3 | |
| SORTIE_QUOTA = 4 | |
| # Une attente imposee plus courte est observee sur place ; au-dela, le script | |
| # s'arrete et dit quand reprendre. | |
| ATTENTE_SUR_PLACE_MAX_S = 600.0 | |
| ESSAIS_PAR_LOT = 3 | |
| LOIS_PAR_COMMIT = 200 | |
| # ==================== JOURNAL ==================== | |
| def charger_verdicts(chemin: Path = JOURNAL) -> Dict[int, dict]: | |
| """Le DERNIER verdict de chaque loi : une passe plus fine remplace la premiere.""" | |
| verdicts: Dict[int, dict] = {} | |
| if not chemin.exists(): | |
| return verdicts | |
| with chemin.open(encoding="utf-8") as journal: | |
| for numero, ligne in enumerate(journal, start=1): | |
| ligne = ligne.strip() | |
| if not ligne: | |
| continue | |
| try: | |
| verdict = json.loads(ligne) | |
| except json.JSONDecodeError: | |
| # Une ligne tronquee par une coupure : les autres restent bonnes. | |
| logger.warning("Ligne %d du journal illisible, ignoree", numero) | |
| continue | |
| verdicts[int(verdict["law_id"])] = verdict | |
| return verdicts | |
| 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 ==================== | |
| def lois_a_classer( | |
| session, | |
| verdicts: Dict[int, dict], | |
| *, | |
| incertains: bool = False, | |
| seuil: float = 0.6, | |
| longueur_extrait: int = 0, | |
| law_ids: Optional[Sequence[int]] = None, | |
| limite: Optional[int] = None, | |
| ) -> List[Law]: | |
| """ | |
| Les lois publiees qui attendent un verdict. | |
| 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 — 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.reference, Law.title, Law.type, Law.status)) | |
| .filter(Law.status == "published") | |
| .order_by(Law.id) | |
| ) | |
| if law_ids: | |
| requete = requete.filter(Law.id.in_(law_ids)) | |
| 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) | |
| and int(verdict.get("extrait") or 0) < max(1, longueur_extrait) | |
| ) | |
| else: | |
| garder = ( | |
| verdict is None | |
| or verdict.get("statut") != "ok" | |
| or verdict.get("consignes") != VERSION_DES_CONSIGNES | |
| ) | |
| if garder: | |
| lois.append(loi) | |
| if limite and len(lois) >= limite: | |
| break | |
| return lois | |
| def extrait_de(session, loi: Law, longueur: int) -> str: | |
| """Le premier chunk `article` ; a defaut, le texte prive de ses visas.""" | |
| if longueur <= 0: | |
| return "" | |
| premier = session.execute( | |
| text( | |
| 'SELECT content FROM articles WHERE law_id = :id AND kind = \'article\' ' | |
| 'ORDER BY "order" LIMIT 1' | |
| ), | |
| {"id": loi.id}, | |
| ).scalar() | |
| 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") | |
| def _heure_de_reprise(secondes: Optional[float]) -> str: | |
| if secondes is None: | |
| return "inconnue" | |
| return (datetime.now() + timedelta(seconds=secondes)).strftime("%d/%m %H:%M") | |
| def classer( | |
| session, | |
| classifieur: LegalDomainClassifier, | |
| *, | |
| journal: Path = JOURNAL, | |
| taille_lot: int = 40, | |
| longueur_extrait: int = 0, | |
| incertains: bool = False, | |
| seuil: float = 0.6, | |
| law_ids: Optional[Sequence[int]] = None, | |
| limite: Optional[int] = None, | |
| dormir: Callable[[float], None] = time.sleep, | |
| ) -> int: | |
| """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, 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( | |
| "%d lois a classer, %d lots de %d au plus (modele %s, extrait %d)", | |
| 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() | |
| for numero, lot in enumerate(lots, start=1): | |
| documents = [ | |
| DocumentAClasser( | |
| titre=loi.title or "", | |
| extrait=extrait_de(session, loi, longueur_extrait), | |
| type_acte=loi.type or None, | |
| ) | |
| for loi in lot | |
| ] | |
| for essai in range(1, ESSAIS_PAR_LOT + 1): | |
| try: | |
| resultat = classifieur.classer_lot( | |
| documents, attente_max=settings.GROQ_ATTENTE_MAX_429_S | |
| ) | |
| break | |
| except ClassementIndisponible as e: | |
| if e.quota: | |
| logger.error( | |
| "⛔ Quota Groq epuise apres %d lots (%s). Reprise possible vers %s : " | |
| "relancer la meme commande, les lois deja classees seront sautees.", | |
| numero - 1, e.raison, _heure_de_reprise(e.retry_after), | |
| ) | |
| return SORTIE_QUOTA | |
| attente = e.retry_after | |
| if essai == ESSAIS_PAR_LOT or attente is None or attente > ATTENTE_SUR_PLACE_MAX_S: | |
| logger.error("⛔ Groq indisponible (%s) : relancer plus tard", e.raison) | |
| return SORTIE_PANNE | |
| logger.warning("Groq sature (%s) : nouvel essai dans %.0f s", e.raison, attente) | |
| dormir(attente) | |
| jetons_total += resultat.jetons | |
| requetes_total += resultat.requetes | |
| with journal.open("a", encoding="utf-8") as sortie: | |
| 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, | |
| "secondaires": [nom for nom, _ in verdict.runners_up] if verdict else [], | |
| "confiance": verdict.confidence if verdict else None, | |
| "modele": resultat.modele, | |
| "consignes": VERSION_DES_CONSIGNES, | |
| "extrait": longueur_extrait, | |
| "lot": numero, | |
| "jetons_lot": resultat.jetons, | |
| "horodatage": _horodatage(), | |
| } | |
| sortie.write(json.dumps(ligne, ensure_ascii=False) + "\n") | |
| a_revoir = sum(1 for v in resultat.verdicts if v is None) | |
| logger.info( | |
| "Lot %d/%d : %d lois, %d a revoir, %d jetons, %d requete(s)", | |
| numero, len(lots), len(lot), a_revoir, resultat.jetons, resultat.requetes, | |
| ) | |
| logger.info( | |
| "✅ %d lots en %.0f s : %d requetes, %d jetons", len(lots), time.time() - debut, | |
| requetes_total, jetons_total, | |
| ) | |
| return 0 | |
| # ==================== APPLIQUER ==================== | |
| class Bilan: | |
| appliquees: int = 0 | |
| changees: int = 0 | |
| protegees: int = 0 | |
| a_revoir: int = 0 | |
| avant: Counter = field(default_factory=Counter) | |
| apres: Counter = field(default_factory=Counter) | |
| def appliquer( | |
| session, | |
| verdicts: Dict[int, dict], | |
| *, | |
| dossier: Path = DOSSIER, | |
| seuil: float = 0.6, | |
| force: bool = False, | |
| dry_run: bool = False, | |
| ) -> Bilan: | |
| """ | |
| 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. 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)} | |
| bilan = Bilan() | |
| changements, a_revoir = [], [] | |
| lois = ( | |
| session.query(Law) | |
| .options(load_only( | |
| Law.id, Law.reference, Law.title, Law.category_id, | |
| Law.category_confidence, Law.suggested_categories, Law.processing_error, | |
| )) | |
| .filter(Law.id.in_(list(verdicts))) | |
| .order_by(Law.id) | |
| .all() | |
| ) | |
| 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 | |
| bilan.apres[actuelle] += 1 | |
| a_revoir.append([ | |
| loi.id, loi.reference, loi.title, actuelle, verdict.get("domaine") or "", | |
| verdict.get("confiance") if verdict.get("confiance") is not None else "", | |
| verdict.get("statut"), | |
| ]) | |
| continue | |
| 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 | |
| bilan.apres[verdict["domaine"]] += 1 | |
| if loi.category_id != cible: | |
| bilan.changees += 1 | |
| changements.append([ | |
| 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 [] | |
| if nom.lower() in carte] | |
| loi.category_id = cible | |
| loi.category_confidence = float(verdict["confiance"]) | |
| loi.suggested_categories = [cible, *[s for s in secondaires if s != cible]] | |
| 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: | |
| session.commit() | |
| dossier.mkdir(parents=True, exist_ok=True) | |
| _ecrire_csv( | |
| dossier / "changements.csv", | |
| ["law_id", "reference", "titre", "avant", "apres", "confiance", "suite"], changements, | |
| ) | |
| _ecrire_csv( | |
| dossier / "a_revoir.csv", | |
| ["law_id", "reference", "titre", "categorie_actuelle", "proposition", "confiance", "statut"], | |
| a_revoir, | |
| ) | |
| 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) | |
| ecrivain.writerow(entete) | |
| ecrivain.writerows(lignes) | |
| def _rapport(bilan: Bilan, dossier: Path, dry_run: bool) -> None: | |
| logger.info("%-55s %7s %7s", "Domaine", "avant", "apres") | |
| for nom in [*CANONICAL_DOMAINS, "(aucune)"]: | |
| if bilan.avant[nom] or bilan.apres[nom]: | |
| 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 ; 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, | |
| ) | |
| logger.info("Relire : %s et %s", dossier / "changements.csv", dossier / "a_revoir.csv") | |
| if bilan.changees and not dry_run: | |
| logger.info( | |
| "Les categories changees sont figees dans embed_text : redecouper et " | |
| "revectoriser les %d lois de changements.csv.", bilan.changees, | |
| ) | |
| # ==================== LIGNE DE COMMANDE ==================== | |
| def construire_parseur() -> argparse.ArgumentParser: | |
| parseur = argparse.ArgumentParser( | |
| description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter | |
| ) | |
| parseur.add_argument("--journal", type=Path, default=JOURNAL) | |
| parseur.add_argument("--seuil", type=float, default=0.6, | |
| help="Confiance minimale d'un verdict applique (defaut 0.6)") | |
| actions = parseur.add_subparsers(dest="action", required=True) | |
| p_classer = actions.add_parser("classer", help="Interroge Groq, ecrit le journal") | |
| p_classer.add_argument("--lot", type=int, default=40, help="Lois par requete (defaut 40)") | |
| p_classer.add_argument("--extrait", type=int, default=0, | |
| help="Caracteres d'extrait par loi, 0 = titre seul (defaut 0)") | |
| p_classer.add_argument("--incertains", action="store_true", | |
| help="Ne redemander que les verdicts a revoir ou sous le seuil") | |
| p_classer.add_argument("--law-id", type=int, action="append", dest="law_ids") | |
| p_classer.add_argument("--limit", type=int, default=None) | |
| p_appliquer = actions.add_parser("appliquer", help="Ecrit les verdicts en base") | |
| p_appliquer.add_argument("--dry-run", action="store_true", | |
| help="N'ecrit rien en base ; produit le rapport et les CSV") | |
| p_appliquer.add_argument("--force", action="store_true", | |
| help="Remplace aussi les categories deja posees") | |
| p_appliquer.add_argument("--dossier", type=Path, default=DOSSIER) | |
| return parseur | |
| def main(argv: Optional[Sequence[str]] = None, classifieur=None) -> int: | |
| logging.basicConfig(level=logging.INFO, format="%(message)s") | |
| args = construire_parseur().parse_args(argv) | |
| with SyncSessionLocal() as session: | |
| manquants = [d for d in CANONICAL_DOMAINS if d.lower() not in load_domain_map(session)] | |
| if manquants: | |
| logger.error("❌ Domaines absents de la table categories : %s", ", ".join(manquants)) | |
| logger.error(" Appliquer d'abord les migrations (alembic upgrade head)") | |
| return SORTIE_CONFIGURATION | |
| if args.action == "classer": | |
| return classer( | |
| session, classifieur or get_legal_domain_classifier(), | |
| journal=args.journal, taille_lot=args.lot, longueur_extrait=args.extrait, | |
| incertains=args.incertains, seuil=args.seuil, | |
| law_ids=args.law_ids, limite=args.limit, | |
| ) | |
| verdicts = charger_verdicts(args.journal) | |
| if not verdicts: | |
| logger.error("❌ Journal vide (%s) : lancer d'abord `classer`", args.journal) | |
| return SORTIE_CONFIGURATION | |
| bilan = appliquer( | |
| session, verdicts, dossier=args.dossier, seuil=args.seuil, | |
| force=args.force, dry_run=args.dry_run, | |
| ) | |
| _rapport(bilan, args.dossier, args.dry_run) | |
| return 0 | |
| if __name__ == "__main__": | |
| sys.exit(main()) | |