"""Les précédents : les étiquettes de auto/ les plus proches d'un texte, par le sens (RAG). manual/ est à l'utilisateur seul : aucun processus ne s'en sert. L'analyste décrit ce qu'il voit sur sa plage ; l'outil rend les étiquettes déjà posées qui en parlent le plus, toutes stations, avec leur provenance (relue, non relue) : à lui de juger si elles valent pour son cas. python3 labeling/precedents.py "les cibles sautent ensemble quand une référence est rejetée par intermittence" python3 labeling/precedents.py "" --exclure NORDEND 2026-11-04T21:12Z 2026-11-07T14:12Z --famille Obstruction --k 5 python3 labeling/precedents.py --index # met l'index à jour seulement python3 labeling/precedents.py --check # contrôle de la logique, sans Ollama L'index (.index/, hors de git) garde le vecteur de chaque texte : à chaque appel, seules les étiquettes nouvelles ou modifiées passent par le modèle. Modèle : bge-m3 servi par Ollama, le conteneur ollama-bge-m3, que l'outil démarre lui-même s'il ne répond pas (`docker start`) ; OLLAMA_URL et RAG_MODELE pour en changer. Bibliothèque standard seulement. """ import argparse import glob import hashlib import json import math import os import subprocess import sys import time import urllib.request from datetime import datetime from pathlib import Path ICI = Path(__file__).resolve().parent URL = os.environ.get("OLLAMA_URL", "http://10.0.2.140:11435") # le port publié par le conteneur ollama-bge-m3 MODELE = os.environ.get("RAG_MODELE", "bge-m3:567m") CONTENEUR = "ollama-bge-m3" # démarré par l'outil s'il ne répond pas INDEX = ICI / ".index" / f"{MODELE.replace(':', '_')}.json" LOT = 32 # textes par appel au modèle def etiquettes(racine=ICI): """Toutes les étiquettes de auto/, avec leur station et leur provenance ; jamais celles de manual/.""" for f in sorted(glob.glob(str(racine / "auto" / "*.jsonl"))): station = Path(f).stem for ligne in open(f, encoding="utf-8"): if ligne.strip(): e = json.loads(ligne) e["station"], e["provenance"] = station, provenance(e) yield e def provenance(e): if e.get("revue"): return f"auto, relue le {e['revue']}" return "auto, non relue" + (f" (analyse {e['analyse']})" if e.get("analyse") else "") def texte(e): return f"{e.get('categorie', '')}. {e.get('description', '')}" def cle(t): return hashlib.sha1(t.encode("utf-8")).hexdigest() def instant(s): return datetime.fromisoformat(s.replace("Z", "+00:00")) def recouvre(e, station, debut, fin): """L'étiquette touche-t-elle la plage exclue (même station, intervalles qui se chevauchent) ?""" return e["station"] == station and instant(e["debut"]) <= instant(fin) and instant(e["fin"]) >= instant(debut) def norme(v): n = math.sqrt(sum(x * x for x in v)) or 1.0 return [round(x / n, 5) for x in v] def demarrer_ollama(attente=120): """Le conteneur ollama-bge-m3 arrêté : `docker start`, puis attendre qu'il réponde -> True s'il répond.""" if subprocess.run(["docker", "start", CONTENEUR], capture_output=True).returncode: return False fin = time.monotonic() + attente while time.monotonic() < fin: try: with urllib.request.urlopen(f"{URL}/api/version", timeout=5): return True except OSError: time.sleep(2) return False def vectoriser(textes): corps = json.dumps({"model": MODELE, "input": textes}).encode() req = urllib.request.Request(f"{URL}/api/embed", corps, {"Content-Type": "application/json"}) for essai in (1, 2): # Ollama arrêté : on démarre son conteneur, une fois, puis on relance try: with urllib.request.urlopen(req, timeout=300) as r: return [norme(v) for v in json.load(r)["embeddings"]] except OSError as err: if essai == 2 or not demarrer_ollama(): sys.exit(f"Ollama injoignable sur {URL} ({err}) : `docker start {CONTENEUR}`, ou OLLAMA_URL.") def index_a_jour(toutes): """Les vecteurs de toutes les étiquettes ; calcule ceux qui manquent, oublie ceux des textes disparus.""" vecteurs = json.loads(INDEX.read_text()) if INDEX.exists() else {} voulus = {cle(texte(e)): texte(e) for e in toutes} manquants = [k for k in voulus if k not in vecteurs] for i in range(0, len(manquants), LOT): lot = manquants[i:i + LOT] vecteurs.update(zip(lot, vectoriser([voulus[k] for k in lot]))) print(f"index : {min(i + LOT, len(manquants))}/{len(manquants)} nouveaux textes", file=sys.stderr) if manquants or len(vecteurs) != len(voulus): vecteurs = {k: vecteurs[k] for k in voulus} INDEX.parent.mkdir(exist_ok=True) INDEX.write_text(json.dumps(vecteurs)) return vecteurs def chercher(requete, toutes, vecteurs, q, k=8, famille=None, exclure=None): retenues = [e for e in toutes if (not famille or e.get("categorie") == famille) and not (exclure and recouvre(e, *exclure))] notes = [(sum(a * b for a, b in zip(q, vecteurs[cle(texte(e))])), e) for e in retenues] return sorted(notes, key=lambda n: -n[0])[:k] def check(): e = {"station": "S", "debut": "2026-11-04T00:00Z", "fin": "2026-11-05T00:00Z"} assert recouvre(e, "S", "2026-11-04T12:00Z", "2026-11-06T00:00Z") assert recouvre(e, "S", "2026-11-03T00:00Z", "2026-11-04T00:00Z") # bord commun : exclue assert not recouvre(e, "S", "2026-11-05T00:01Z", "2026-11-06T00:00Z") assert not recouvre(e, "T", "2026-11-04T12:00Z", "2026-11-06T00:00Z") assert provenance({"revue": "2026-11-04"}) == "auto, relue le 2026-11-04" import tempfile # seules les étiquettes de auto/ servent : manual/ est à l'utilisateur seul with tempfile.TemporaryDirectory() as d: for sous, desc in (("manual", "de l'utilisateur"), ("auto", "d'un agent")): (Path(d) / sous).mkdir() (Path(d) / sous / "S.jsonl").write_text(json.dumps({**e, "description": desc}) + "\n", encoding="utf-8") assert [x["description"] for x in etiquettes(Path(d))] == ["d'un agent"] assert provenance({"analyse": "X"}) == "auto, non relue (analyse X)" a, b = {**e, "categorie": "A", "description": "a"}, {**e, "station": "T", "categorie": "B", "description": "b"} vec = {cle(texte(a)): [1.0, 0.0], cle(texte(b)): [0.6, 0.8]} assert [x["categorie"] for _, x in chercher("", [a, b], vec, [0.0, 1.0])] == ["B", "A"] assert [x["categorie"] for _, x in chercher("", [a, b], vec, [0.0, 1.0], exclure=("T", e["debut"], e["fin"]))] == ["A"] assert [x["categorie"] for _, x in chercher("", [a, b], vec, [0.0, 1.0], famille="A")] == ["A"] appels, reponses = [], iter([OSError("refusé"), {"embeddings": [[3.0, 4.0]]}]) # Ollama arrêté : démarré, puis la relance passe class Reponse: def __init__(self, r): self.r = r def __enter__(self): return self def __exit__(self, *a): return False def read(self): return json.dumps(self.r).encode() def ouvrir(*a, **k): r = next(reponses) if isinstance(r, Exception): raise r return Reponse(r) avant = urllib.request.urlopen, globals()["demarrer_ollama"] urllib.request.urlopen, globals()["demarrer_ollama"] = ouvrir, lambda: appels.append(1) or True try: assert vectoriser(["x"]) == [[0.6, 0.8]] and appels == [1], appels finally: urllib.request.urlopen, globals()["demarrer_ollama"] = avant print("ok") def main(): p = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) p.add_argument("requete", nargs="?", help="ce que tu vois, en français, comme une description d'étiquette") p.add_argument("--k", type=int, default=8, help="nombre de précédents (8)") p.add_argument("--famille", help="seulement cette famille (clé de familles.md)") p.add_argument("--exclure", nargs=3, metavar=("STATION", "DEBUT", "FIN"), help="la plage que tu analyses : ses étiquettes sont écartées") p.add_argument("--index", action="store_true", help="met l'index à jour et s'arrête") p.add_argument("--check", action="store_true", help="contrôle de la logique, sans Ollama") a = p.parse_args() if a.check: return check() toutes = list(etiquettes()) vecteurs = index_a_jour(toutes) if a.index: return print(f"{len(vecteurs)} étiquettes indexées ({MODELE}) : {INDEX}") if not a.requete: p.error("donne un texte, ou --index") for note, e in chercher(a.requete, toutes, vecteurs, vectoriser([a.requete])[0], a.k, a.famille, a.exclure): print(f"## {e.get('id', 'sans id')} — {e.get('categorie') or 'sans famille'} — {e['station']} {e['debut']} → {e['fin']}\n" f"similarité {note:.2f} ; {e['provenance']}\n{e['description']}\n") if __name__ == "__main__": main()