Files
aimsight-app/app/serveur/analyse.py
T

297 lines
16 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""L'onglet Analysis de la page Data : un analyste (l'étiqueteur, .claude/agents/etiqueteur.md) lancé par `claude -p`, non
interactif, sur une plage choisie dans la page, avec les indices facultatifs de l'utilisateur. Il écrit dans
labeling/auto/analyses/<STATION>_<début>_<fin>/ ses étiquettes (etiquettes.jsonl) et un rapport de diagnostic (rapport.md, ses
figures à côté) ; à la fin, le serveur verse ses étiquettes dans labeling/auto/<STATION>.jsonl, marquées de leur analyse
(champ `analyse`, sans `revue` : à relire par /review-auto-labels). Puis l'utilisateur peut lui écrire : la même
session reprend (`claude -p --resume`), et ses étiquettes, si elles changent, remplacent celles qu'il avait versées.
Sur une analyse finie, « Optimiser » lance `/detector-learner <analyse>` par `claude -p` (D-148) : les détecteurs, puis les outils de
lecture, améliorés depuis l'analyse ; une optimisation à la fois, ni analyse ni message pendant ; son bilan,
detector-learner/<séance>_<analyse>/bilan.md, s'affiche sous le rapport.
"""
import html
import json
import os
import subprocess
import threading
from datetime import datetime, timezone
import markdown
import station
DOSSIER = station.ETIQUETTES / "auto" / "analyses"
SEANCES = station.RACINE / "detector-learner" # les séances de /detector-learner, <séance>_<analyse>/
CONSIGNE = """Tu travailles pour la page Data de la web app : l'utilisateur a sélectionné une plage et te demande de la \
diagnostiquer. Ce n'est pas un lot ordinaire : il y a vu une anomalie que les détecteurs captent mal, ou il veut une analyse \
plus poussée.
- Station : data/{station}/
- Lot : {debut} → {fin} (UTC)
- Dossier de sortie : {sortie}/ (tes figures de travail et les sorties des outils dans {sortie}/travail/)
- Indices de l'utilisateur : {indices}
Fais ton travail d'étiqueteur sur ce lot, à ces différences près :
1. Tes étiquettes vont dans {sortie}/etiquettes.jsonl ; c'est le serveur qui les versera dans labeling/auto/{station}.jsonl. \
Celles qui y sont déjà sur la plage (lis-les) restent : ne refais pas une étiquette juste ; une étiquette que tu crois fausse, \
dis-le dans le rapport.
2. En plus de {sortie}/analyse.md, écris {sortie}/rapport.md, le rapport de diagnostic que l'utilisateur lira dans la page, \
en français, comme l'analyse d'un cas du support :
- `# {station} : <le sujet en quelques mots>`, puis la question (sa sélection, ses indices) en une ou deux phrases ;
- « Ce que montrent les données » : chaque événement daté (UTC), les capteurs touchés et ceux qui ne bougent pas, la \
cause et son niveau de preuve (confirmed / strongly supported / consistent with / possible / insufficient evidence / not \
observed), la commande qui fonde chaque fait ;
- les figures qui prouvent, chacune insérée par `![légende](chemin relatif à {sortie}/)` et suivie d'une ligne qui dit ce \
qu'on y voit : courbes (graphique.py), vignettes, images entières de la caméra (copie-les dans {sortie}/ avec cp) ; \
quelques-unes, choisies, pas toutes celles de travail ;
- « Ce qui reste non établi » ; « Étiquettes » : celles que tu proposes, en une ligne chacune.
Réponds en 2 lignes : le nombre d'étiquettes, le chemin du rapport."""
# nom -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...], "versees": n} ; une analyse à la fois par plage
analyses, verrou = {}, threading.Lock()
# nom de l'analyse -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...]} ; une optimisation à la fois, toutes analyses
optimisations = {}
OCCUPE = "une optimisation des détecteurs est en cours"
def _optimise():
return any(o["etat"] == "en cours" for o in optimisations.values())
def lancer(corps):
st, debut, fin = corps.get("station"), corps.get("debut"), corps.get("fin")
station._valide({"description": "-"}, debut, fin)
station.dossier(st)
nom = f"{st}_{debut[:16].replace(':', '')}_{fin[:16].replace(':', '')}"
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if analyses.get(nom, {}).get("etat") == "en cours":
raise station.Refus("cette plage est déjà en cours d'analyse")
sortie = DOSSIER / nom
if sortie.exists(): # une nouvelle analyse de la même plage : l'ancienne reste, à côté
nom += datetime.now(timezone.utc).strftime("_%H%M%S")
sortie = DOSSIER / nom
indices = (corps.get("indices") or "").strip()
demande = {"station": st, "debut": debut, "fin": fin, "indices": indices}
analyses[nom] = {"etat": "en cours", "lignes": [], "versees": 0, "station": st, "demande": demande}
(sortie / "travail").mkdir(parents=True)
(sortie / "demande.json").write_text(json.dumps(demande, ensure_ascii=False, indent=1), encoding="utf-8")
prompt = CONSIGNE.format(station=st, debut=debut, fin=fin, sortie=sortie.relative_to(station.RACINE),
indices=indices or "aucun")
threading.Thread(target=travailler, args=(nom, sortie, prompt), daemon=True).start()
return {"nom": nom}
def travailler(nom, sortie, prompt, reprise=None):
"""Un tour de l'analyste : la demande, ou un message de l'utilisateur dans la même session (reprise : son id)."""
a = analyses[nom]
try:
p = subprocess.Popen(["claude", "-p", prompt, "--agent", "etiqueteur", "--output-format", "stream-json", "--verbose",
"--allowedTools", "Read,Write,Bash", "--permission-mode", "acceptEdits"]
+ (["--resume", reprise] if reprise else []),
cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal:
for ligne in p.stdout:
journal.write(ligne)
a["lignes"] += resume(ligne)
if '"subtype":"init"' in ligne: # la session, pour les messages suivants
(sortie / "travail" / "session").write_text(json.loads(ligne)["session_id"])
if p.wait():
raise RuntimeError(f"claude a fini avec le code {p.returncode}")
a["versees"] = verser(a["station"], nom, sortie)
a["etat"] = "fini"
except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue
a["lignes"].append(f"Erreur : {e}")
a["etat"] = "erreur"
def message(nom, corps):
"""Un message de l'utilisateur à l'analyste, après son rapport : la même session reprend (claude -p --resume)."""
texte, sortie = (corps.get("texte") or "").strip(), DOSSIER / nom
etat(nom) # le nom vérifié, l'état relu après un redémarrage
a, session = analyses[nom], sortie / "travail" / "session"
if not texte or not session.exists():
raise station.Refus("message vide, ou l'analyse n'a pas de session à reprendre")
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if a["etat"] == "en cours":
raise station.Refus("l'analyste travaille encore")
a["etat"] = "en cours"
ligne = json.dumps({"type": "page", "texte": texte}, ensure_ascii=False) + "\n"
with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal:
journal.write(ligne)
a["lignes"] += resume(ligne)
prompt = (f"{texte}\n\n(Si tu changes tes étiquettes, réécris {sortie.relative_to(station.RACINE)}/etiquettes.jsonl en "
"entier, le serveur les reversera ; si le diagnostic change, mets rapport.md à jour.)")
threading.Thread(target=travailler, args=(nom, sortie, prompt, session.read_text()), daemon=True).start()
return {}
def resume(ligne):
"""Une ligne du journal -> ce que la page en montre : les messages de l'utilisateur (« › »), les textes de l'analyste, ses
outils et leur commande, en une ligne chacun."""
try:
m = json.loads(ligne)
except json.JSONDecodeError:
return [ligne.strip()[:200]] if ligne.strip() else []
if m.get("type") == "page":
return [f"› {m['texte']}"]
if m.get("type") != "assistant":
return []
out = []
for c in m["message"].get("content", []):
if c.get("type") == "text" and c["text"].strip():
out.append(c["text"].strip()[:300])
elif c.get("type") == "tool_use":
i = c.get("input", {})
out.append(f"{c['name']} : {i.get('command') or i.get('file_path') or ''}"[:200])
return out
def verser(st, nom, sortie):
"""Les étiquettes de l'analyse dans labeling/auto/<STATION>.jsonl, avec leur id et le nom de l'analyse ; si l'analyste les
a changées depuis le dernier versement, elles remplacent celles qu'il y avait versées -> leur nombre."""
fichier, copie = sortie / "etiquettes.jsonl", sortie / "travail" / "versees.jsonl"
texte = fichier.read_text(encoding="utf-8") if fichier.exists() else ""
nouvelles = []
for l in texte.split("\n"):
if l.strip():
e = json.loads(l)
station._valide(e, e.get("debut"), e.get("fin"))
nouvelles.append({k: e[k] for k in ("debut", "fin", "categorie", "description") if k in e} | {"analyse": nom})
if copie.exists() and copie.read_text(encoding="utf-8") == texte:
return len(nouvelles)
# ponytail: retirées puis remises, les étiquettes de l'analyse perdent les retouches faites dans la page ; les garder
# demanderait de les apparier une à une
with verrou:
f = station.fichier(st, "auto") # les autres lignes restent telles quelles
gardees = [l for l in (f.read_text(encoding="utf-8").split("\n") if f.exists() else [])
if l.strip() and json.loads(l).get("analyse") != nom]
station.attribuer(st, [json.loads(l) for l in gardees] + nouvelles)
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("".join(l + "\n" for l in gardees + [json.dumps(e, ensure_ascii=False) for e in nouvelles]),
encoding="utf-8")
os.replace(provisoire, f)
copie.write_text(texte, encoding="utf-8")
return len(nouvelles)
def etat(nom):
sortie = DOSSIER / nom
if "/" in nom or nom.startswith(".") or not sortie.is_dir():
raise station.Refus("analyse inconnue")
if nom not in analyses: # après un redémarrage du serveur, il ne reste que le dossier : le fil se relit dans le journal
journal = sortie / "travail" / "journal.jsonl"
lignes = [r for l in open(journal, encoding="utf-8") for r in resume(l)] if journal.exists() else []
demande = json.loads((sortie / "demande.json").read_text(encoding="utf-8"))
analyses[nom] = {"etat": "fini" if (sortie / "rapport.md").exists() else "interrompue", "lignes": lignes,
"versees": None, "station": demande["station"], "demande": demande}
a, r = analyses[nom], sortie / "rapport.md"
return {"nom": nom, "etat": a["etat"], "lignes": a["lignes"], "versees": a["versees"],
"rapport": int(r.stat().st_mtime) if r.exists() else None,
"dialogue": (sortie / "travail" / "session").exists(), "demande": a["demande"], "optimisation": optimisation(nom)}
def liste():
"""L'historique des analyses (la barre latérale), la plus récente en tête : celles du serveur avec leur état, les autres
lues sur le disque (fini avec un rapport, sinon interrompue : une analyse s'arrête avec le serveur)."""
out = []
for d in sorted(DOSSIER.glob("*/demande.json"), key=lambda f: f.parent.stat().st_mtime, reverse=True):
nom = d.parent.name
a = analyses.get(nom) or {"etat": "fini" if (d.parent / "rapport.md").exists() else "interrompue",
"demande": json.loads(d.read_text(encoding="utf-8"))}
out.append({"nom": nom, "etat": a["etat"]} | a["demande"])
return out
def fichier(nom, chemin):
"""Un fichier du dossier de l'analyse (le rapport, ses figures), jamais au-dehors."""
f = (DOSSIER / nom / chemin).resolve()
if not f.is_file() or not f.is_relative_to(DOSSIER.resolve()):
raise station.Refus("fichier inconnu")
return f
STYLE = """body{font:14px/1.55 Roboto,sans-serif;margin:0;padding:4px 2px;color:#212529;background:transparent}
h1{font-size:20px}h2{font-size:16px;margin-top:22px}img{max-width:100%;border:1px solid #dee2e6;border-radius:4px}
code{font-size:12px;background:#f1f3f5;padding:1px 4px;border-radius:3px}pre{overflow-x:auto}
table{border-collapse:collapse}td,th{border:1px solid #dee2e6;padding:3px 8px;text-align:left}
body.sombre{color:#c9c9c9}body.sombre code{background:#2e2e2e}body.sombre td,body.sombre th,body.sombre img{border-color:#424242}"""
def _page(chemin, titre, sombre):
"""Un markdown en HTML, au style de la page ; ses images relatives se résolvent dans le dossier de l'adresse."""
corps = markdown.markdown(chemin.read_text(encoding="utf-8"), extensions=["tables", "fenced_code"])
return (f"<!doctype html><meta charset=utf-8><title>{html.escape(titre)}</title><style>{STYLE}</style>"
f"<body class='{'sombre' if sombre else ''}'>{corps}</body>")
def rapport(nom, sombre):
"""rapport.md en HTML, servi dans le dossier de l'analyse : ses images relatives s'y retrouvent."""
return _page(fichier(nom, "rapport.md"), nom, sombre)
# --- « Optimiser » : /detector-learner <analyse> par claude -p (D-148)
def _bilan(nom):
"""Le bilan de la dernière séance de cette analyse, ou None."""
bilans = sorted(SEANCES.glob(f"*_{nom}/bilan.md")) # <séance> en tête du nom : l'ordre du nom est celui du temps
return bilans[-1] if bilans else None
def optimisation(nom):
"""-> None (jamais optimisée) ou {etat, lignes, bilan : mtime du dernier bilan}. Après un redémarrage, l'état se relit sur
le disque : fini si un bilan est plus récent que le flux, sinon interrompue."""
flux, b = DOSSIER / nom / "travail" / "optimisation.jsonl", _bilan(nom)
o = optimisations.get(nom)
if o is None:
if not flux.exists():
return None if b is None else {"etat": "fini", "lignes": [], "bilan": int(b.stat().st_mtime)}
o = {"etat": "fini" if b and b.stat().st_mtime >= flux.stat().st_mtime else "interrompue",
"lignes": [r for l in open(flux, encoding="utf-8") for r in resume(l)]}
optimisations[nom] = o
return {"etat": o["etat"], "lignes": o["lignes"], "bilan": int(b.stat().st_mtime) if b else None}
def optimiser(nom):
"""Le bouton « Optimiser » sur une analyse finie : la séance dans un fil ; refusée si une optimisation ou une analyse tourne."""
if etat(nom)["etat"] != "fini":
raise station.Refus("seule une analyse finie s'optimise")
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if any(a["etat"] == "en cours" for a in analyses.values()):
raise station.Refus("une analyse est en cours : l'optimisation attend sa fin")
optimisations[nom] = {"etat": "en cours", "lignes": []}
threading.Thread(target=optimiser_fil, args=(nom,), daemon=True).start()
return {}
def optimiser_fil(nom):
o = optimisations[nom]
try:
p = subprocess.Popen(["claude", "-p", f"/detector-learner {nom}", "--output-format", "stream-json", "--verbose",
"--allowedTools", "Read,Write,Edit,Bash,Agent", "--permission-mode", "acceptEdits"],
cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
(DOSSIER / nom / "travail").mkdir(exist_ok=True)
with open(DOSSIER / nom / "travail" / "optimisation.jsonl", "a", encoding="utf-8") as flux:
for ligne in p.stdout:
flux.write(ligne)
o["lignes"] += resume(ligne)
if p.wait():
raise RuntimeError(f"claude a fini avec le code {p.returncode}")
o["etat"] = "fini"
except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue
o["lignes"].append(f"Erreur : {e}")
o["etat"] = "erreur"
finally:
station.detecteurs.cache_clear() # les détecteurs ont pu changer : la page Data les recalcule
def bilan(nom, sombre):
b = _bilan(nom)
if b is None:
raise station.Refus("aucun bilan pour cette analyse")
return _page(b, nom, sombre)