L'app de diagnostic, ses agents et ce dont ils ont besoin, copiés de Support-Agent ; sans la page Support

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-13 11:32:43 +01:00
1 parent 8d5dc4a31c
commit 56f0c902d7
112 files changed
+13047

No files matched your search

+296
View File
@@ -0,0 +1,296 @@
"""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)
+168
View File
@@ -0,0 +1,168 @@
"""Vérifications de la web app, sans appel à claude : .venv/bin/python app/serveur/check.py [nom]"""
import json
import shutil
import socket
import sys
import tempfile
import threading
import time
import urllib.request
from pathlib import Path
from urllib.error import HTTPError
ICI = Path(__file__).resolve().parent
sys.path.insert(0, str(ICI))
import uvicorn # noqa: E402
import serveur # noqa: E402
import station # noqa: E402
def seance_temporaire():
return Path(tempfile.mkdtemp())
def check_serveur():
# le vrai serveur sur un port libre : la garde (Host, JSON déclaré), une lecture
with socket.socket() as so:
so.bind(("127.0.0.1", 0))
port = so.getsockname()[1]
srv = uvicorn.Server(uvicorn.Config(serveur.app, host="127.0.0.1", port=port, log_level="error"))
threading.Thread(target=srv.run, daemon=True).start()
while not srv.started:
time.sleep(0.05)
base = f"http://127.0.0.1:{port}"
def appel(chemin, corps=None, entetes=None, methode=None):
r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None,
{"Content-Type": "application/json", **(entetes or {})}, method=methode)
try:
with urllib.request.urlopen(r) as rep:
return rep.status
except HTTPError as e:
return e.code
try:
assert appel("/api/stations", entetes={"Host": "evil.example:80"}) == 403
assert appel("/api/etiquettes", {"station": "x"}, {"Content-Type": "text/plain"}) == 403
assert appel("/api/stations") == 200
assert appel("/api/analyses") == 200
assert appel("/api/analyses/INCONNUE/optimiser", {}) == 400
finally:
srv.should_exit = True
def leve(f, *a):
try:
f(*a)
except station.Refus as e:
return str(e)
raise AssertionError(f"{f.__name__}{a} n'a pas refusé")
def check_station():
# les données de la page Data, sur les vraies données ; les étiquettes dans un dossier temporaire
assert "NIEDERHORN" in station.stations()
im = station.images("NIEDERHORN", "2026-09-25", "2026-09-26")
assert im["images"] and im["positions"] and set(im["corr"]) == set(im["positions"]), list(im)
assert all(len(c) == len(im["images"]) for c in im["corr"].values())
assert station.image("NIEDERHORN", im["images"][0]["nom"]).is_file()
leve(station.image, "NIEDERHORN", "../../../.env")
leve(station.images, "../API", "", "")
assert station.images("LENZSPITZE", "2026-10-26", "2026-10-27")["images"]
c = station.courbes("LENZSPITZE", "2026-10-26", "2026-10-27")
titres = [p["titre"] for p in c["plots"]]
assert "Relative Corrected Vertical Shift" in titres and any(t.startswith("System: ") for t in titres), titres
ev = station.detecteurs("LENZSPITZE", "2026-10-26", "2026-10-27") # les détecteurs du journal, ~10 s
assert ev and {"debut", "fin", "categorie", "description", "capteurs"} <= set(ev[0]), ev[:1]
assert all(e["message"] and e["action"] and set(e["cibles"] + e["references"]) == set(e["capteurs"]) for e in ev), ev[:1]
assert station.message("A moved; nothing to do. The jump of 2 targets in this period has the same cause.") \
== "A moved. The jump of 2 targets in this period has the same cause."
assert all(e["fin"] >= "2026-10-26T00:00Z" and e["debut"] < "2026-10-27T00:00Z" for e in ev), [(e["debut"], e["fin"]) for e in ev]
assert not any("SIM_CCID" in t or t.startswith("System: ip") for t in titres)
assert all(len(c["T"][tr["t"]]) == len(tr["y"]) for p in c["plots"] for tr in p["traces"])
avant, station.ETIQUETTES = station.ETIQUETTES, seance_temporaire()
try:
e = station.ajouter({"station": "NIEDERHORN", "dossier": "auto", "debut": "2026-09-25T01:00Z",
"fin": "2026-09-25T02:00Z", "categorie": "Visibility", "description": "brouillard"})
assert e["id"] == "NIEDERHORN-1" and next(iter(e)) == "id", e
e2 = station.modifier({"station": "NIEDERHORN", "dossier": "auto", "avant": e,
"debut": e["debut"], "fin": e["fin"], "categorie": "", "description": "pluie"})
assert e2 == {"id": "NIEDERHORN-1", "debut": e["debut"], "fin": e["fin"], "description": "pluie"}, e2
assert station.lire("NIEDERHORN", "auto") == [e2]
assert "plus dans le fichier" in leve(station.supprimer, {"station": "NIEDERHORN", "dossier": "auto", "avant": e})
station.supprimer({"station": "NIEDERHORN", "dossier": "auto", "avant": e2})
assert station.lire("NIEDERHORN", "auto") == []
leve(station.ajouter, {"station": "NIEDERHORN", "dossier": "../x", "debut": "a", "fin": "b", "description": "x"})
leve(station.ajouter, {"station": "NIEDERHORN", "debut": "2026-09-25T02:00Z", "fin": "2026-09-25T01:00Z", "description": "x"})
finally:
shutil.rmtree(station.ETIQUETTES)
station.ETIQUETTES = avant
def check_optimisation():
# le bouton Optimiser (analyse.optimiser), sans claude : un faux processus qui ne finit que sur signal, une analyse finie
# copiée dans un dossier temporaire ; le verrou (une optimisation à la fois, ni analyse ni message pendant), l'état
# relu après un redémarrage
import analyse
fin = threading.Event()
class FauxProcessus:
returncode = 0
stdout = iter(lambda: fin.wait() and "", "") # rien, jusqu'au signal
def __init__(self, *a, **k):
pass
def wait(self):
return 0
avant = analyse.DOSSIER, analyse.SEANCES, analyse.subprocess.Popen
analyse.DOSSIER, analyse.SEANCES = seance_temporaire(), seance_temporaire()
analyse.subprocess.Popen = FauxProcessus
try:
for nom in ("NORDEND_a", "NORDEND_b"):
(analyse.DOSSIER / nom / "travail").mkdir(parents=True)
(analyse.DOSSIER / nom / "demande.json").write_text(json.dumps(
{"station": "NORDEND", "debut": "2026-11-04T21:12Z", "fin": "2026-11-07T14:12Z", "indices": ""}))
(analyse.DOSSIER / nom / "rapport.md").write_text("# rapport")
assert analyse.etat("NORDEND_a")["optimisation"] is None
assert analyse.optimiser("NORDEND_a") == {}
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours"
leve(analyse.optimiser, "NORDEND_a")
leve(analyse.optimiser, "NORDEND_b")
leve(analyse.lancer, {"station": "NORDEND", "debut": "2026-11-04T00:00Z", "fin": "2026-11-05T00:00Z"})
leve(analyse.message, "NORDEND_b", {"texte": "continue"})
fin.set()
while analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours":
time.sleep(0.05)
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "fini"
analyse.analyses["NORDEND_b"]["etat"] = "en cours" # une analyse qui tourne bloque l'optimisation
leve(analyse.optimiser, "NORDEND_a")
# après un redémarrage : un flux sans bilan plus récent -> interrompue ; un bilan plus récent -> fini, rendu en HTML
analyse.analyses.clear()
analyse.optimisations.clear()
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "interrompue"
time.sleep(0.01)
(analyse.SEANCES / "2026-11-13T1000Z_NORDEND_a").mkdir()
(analyse.SEANCES / "2026-11-13T1000Z_NORDEND_a" / "bilan.md").write_text("# Optimisation\n\n**Résultat** : aucune")
analyse.optimisations.clear()
o = analyse.etat("NORDEND_a")["optimisation"]
assert o["etat"] == "fini" and o["bilan"], o
assert "<strong>Résultat</strong>" in analyse.bilan("NORDEND_a", False)
assert analyse.etat("NORDEND_b")["optimisation"] is None
finally:
fin.set()
shutil.rmtree(analyse.DOSSIER)
shutil.rmtree(analyse.SEANCES)
analyse.DOSSIER, analyse.SEANCES, analyse.subprocess.Popen = avant
analyse.analyses.clear()
analyse.optimisations.clear()
CHECKS = [check_serveur, check_station, check_optimisation]
if __name__ == "__main__":
nom = sys.argv[1] if len(sys.argv) > 1 else None
for f in CHECKS:
if nom in (None, f.__name__):
f()
print("ok", f.__name__)
+165
View File
@@ -0,0 +1,165 @@
"""La web app : .venv/bin/python app/serveur/serveur.py → http://127.0.0.1:8770
Le serveur FastAPI sert la page React construite (app/web/dist, `npm run build` dans app/web) et l'API sous /api.
La page Data lit data/ et les étiquettes de labeling/ (station.py) ; son onglet Analysis lance l'étiqueteur, et l'optimisation
des détecteurs (analyse.py).
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_PORT (port, 8770).
"""
import json
import os
import platform
import subprocess
import sys
import threading
import webbrowser
from pathlib import Path
import uvicorn
from fastapi import FastAPI, Query, Request
from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
import analyse
import station
from fastapi.staticfiles import StaticFiles
APP = Path(__file__).resolve().parents[1]
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit pas les données
PAGE = APP / "web" / "dist"
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def erreur(code: int, texte: str) -> JSONResponse:
return JSONResponse({"erreur": texte}, code)
@app.middleware("http")
async def garde(request: Request, suite):
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
hote = request.headers.get("host", "").rsplit(":", 1)[0]
if hote not in HOTES or (request.method in ("POST", "PUT", "DELETE")
and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée")
return await suite(request)
# --- la page Data (station.py)
@app.exception_handler(station.Refus)
def refus(_, e):
return erreur(400, str(e))
@app.get("/api/stations")
def stations():
return station.stations()
@app.get("/api/images")
def images(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.images(station_, du, au)
@app.get("/api/image/{station_}/{nom}")
def image(station_: str, nom: str):
return FileResponse(station.image(station_, nom), headers={"Cache-Control": "max-age=86400"})
@app.get("/api/courbes")
def courbes(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.courbes(station_, du, au)
@app.get("/api/detecteurs")
def detecteurs(station_: str = Query(alias="station"), du: str = "", au: str = "", cibles: str = ""):
return station.detecteurs(station_, du, au, cibles)
@app.get("/api/etiquettes")
def etiquettes(station_: str = Query(alias="station"), dossier: str = "manual"):
try:
return station.lire(station_, dossier)
except json.JSONDecodeError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
return erreur(500, f"labeling/{dossier}/{station_}.jsonl illisible : {e}")
@app.post("/api/etiquettes")
def ajouter(corps: dict):
return station.ajouter(corps)
@app.put("/api/etiquettes")
def modifier(corps: dict):
return station.modifier(corps)
@app.delete("/api/etiquettes")
def supprimer(corps: dict):
return station.supprimer(corps)
# --- l'onglet Analysis de la page Data (analyse.py) : l'étiqueteur lancé par claude -p sur une plage
@app.post("/api/analyses")
def lancer_analyse(corps: dict):
return analyse.lancer(corps)
@app.get("/api/analyses")
def analyses():
return analyse.liste()
@app.get("/api/analyses/{nom}")
def etat_analyse(nom: str):
return analyse.etat(nom)
@app.post("/api/analyses/{nom}/message")
def message_analyse(nom: str, corps: dict):
return analyse.message(nom, corps)
@app.get("/api/analyses/{nom}/rapport.html")
def rapport_analyse(nom: str, sombre: bool = False):
return HTMLResponse(analyse.rapport(nom, sombre))
@app.post("/api/analyses/{nom}/optimiser")
def optimiser_analyse(nom: str):
return analyse.optimiser(nom)
@app.get("/api/analyses/{nom}/bilan.html")
def bilan_analyse(nom: str, sombre: bool = False):
return HTMLResponse(analyse.bilan(nom, sombre))
@app.get("/api/analyses/{nom}/{chemin:path}")
def fichier_analyse(nom: str, chemin: str):
return FileResponse(analyse.fichier(nom, chemin))
if PAGE.is_dir():
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
else:
@app.get("/")
def sans_page():
return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build")
def ouvrir(url: str) -> None:
if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
else:
webbrowser.open(url)
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
print(f"Diagnostic AIMsight : {url}")
if "--sans-navigateur" not in sys.argv:
threading.Timer(1, ouvrir, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)
+331
View File
@@ -0,0 +1,331 @@
"""Les données de la page Data : les images d'une station, ses courbes, ses étiquettes.
Repris de view/view.py et labeling/labeling.py (le calcul, pas les pages) ; positions, references, COULEURS, POSE et
attribuer sont copiés de detectors-view/detecteurs.py et labeling/ids.py (app/README.md, « Copies »). La lecture des données est
celle des agents, agent-tools/donnees.py ; les événements des détecteurs, ceux du journal,
detectors/categories.py (D-140). Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/.
"""
import bisect
import functools
import csv
import glob
import json
import os
import re
import statistics
import sys
from datetime import datetime, timedelta
from pathlib import Path
RACINE = Path(__file__).resolve().parents[2]
sys.path[:0] = [str(RACINE / "agent-tools"), str(RACINE / "detectors")]
import donnees # noqa: E402
from categories import evenements # noqa: E402
DONNEES = Path(os.environ.get("AIMSIGHT_DATA", RACINE / "data")).resolve()
ETIQUETTES = Path(os.environ.get("AIMSIGHT_LABELS", RACINE / "labeling")).resolve()
DOSSIERS = ("auto", "manual") # celles de l'étiqueteur (D-105), celles de Marc (D-102)
FAMILLES = ("Visibility", "Obstruction", "Thermal displacement", "Displacement", "Target issue", "No data", "None") # D-109
FORMAT = "%Y-%m-%dT%H:%MZ"
MARGE_PX = 150 # detecteurs.MARGE_PX : x, y ne sont des positions dans l'image que loin du coin
COULEURS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # un capteur chacun
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d"))
# Le menu Advanced d'Explore, dans son ordre (labeling.PLOTS, QUALITE)
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
QUALITE = (("peak", "Quality: Peak"), ("flux", "Quality: Flux"), ("sharpness", "Quality: Sharpness"),
("fwhm", "Quality: FWHM [px]"), ("dominance", "Quality: Dominance"), ("snr", "Quality: SNR"))
IDENTIFIANT = re.compile(r"(SIM_CCID|ip(_.*)?)$") # jamais lus (CLAUDE.md, « data/ »)
METRIQUE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
class Refus(ValueError):
"""Une demande à refuser (400), avec sa raison."""
def stations():
return sorted(d.name for d in DONNEES.iterdir() if d.is_dir())
def dossier(station):
if station not in stations(): # le nom devient un chemin : un dossier de data/, rien d'autre
raise Refus(f"station inconnue : {station}")
return DONNEES / station
def bornes(du, au):
return donnees.instant(du or "0001-01-01"), donnees.instant(au or "9999-01-01")
# --- detectors-view/detecteurs.py
def positions(mesures, a, b):
"""La position médiane de chaque capteur dans l'image sur [a, b) ({} si x, y n'y sont pas des positions)."""
maisons = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in mesures.items()
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
return maisons if any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()) else {}
def references(mesures, a, b):
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (références seulement)."""
return {s for s, ms in mesures.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)}
# --- les images de la page Data (view/view.py)
def images(station, du, au):
"""Les images de [du, au), les positions médianes des capteurs, les références, et par capteur entouré son corr_x,
corr_y à l'heure de chaque image : la mesure valide la plus proche, à 30 min près, sinon 0."""
d, (a, b) = dossier(station), bornes(du, au)
vues = [(t, im) for im in sorted(glob.glob(str(d / "images" / "*"))) if (t := donnees.heure_image(im)) and a <= t < b]
if not vues:
raise Refus(f"aucune image de {station} sur cette plage")
mesures = donnees.charger(d)
maisons, refs = positions(mesures, a, b), references(mesures, a, b)
# ponytail: une seule mesure à chaque borne, bruitée ; une médiane sur une fenêtre si les flèches tremblent trop
marge, corr = timedelta(minutes=30), {}
for s in maisons:
serie = [(m["t"], m["corr_x"], m["corr_y"]) for m in mesures[s] if m["corr_x"] is not None and m["corr_y"] is not None]
temps, corr[s] = [m[0] for m in serie], []
for t, _ in vues:
k = bisect.bisect_left(temps, t)
k = min((n for n in (k - 1, k) if 0 <= n < len(serie)), key=lambda n: abs(temps[n] - t), default=None)
corr[s].append([round(serie[k][1], 4), round(serie[k][2], 4)] if k is not None and abs(temps[k] - t) <= marge else 0)
return {"images": [{"t": donnees.iso(t).replace("T", " ").rstrip("Z"), "nom": os.path.basename(im)} for t, im in vues],
"positions": {s: [round(x, 1), round(y, 1)] for s, (x, y) in sorted(maisons.items())},
"references": sorted(refs), "corr": corr}
def image(station, nom):
f = (dossier(station) / "images" / nom).resolve()
if f.parent != (DONNEES / station / "images").resolve() or not f.is_file():
raise Refus("image inconnue")
return f
# --- la page Data (labeling/labeling.py)
def metriques(d, a, b):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}} (une valeur vide : None, le
trou se voit), sans les métriques texte, les identifiants, ni celles qui n'ont aucune valeur."""
station, series, texte = d.name + "_", {}, set()
for p in sorted(glob.glob(str(d / "metrics" / "*.csv"))):
if not (m := METRIQUE.match(os.path.basename(p))) or IDENTIFIANT.match(nom := m.group(1).removeprefix(station)):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
t, v = donnees.instant(r["time_utc"]), (r.get("metric") or "").strip("[]'\" ")
if not a <= t < b:
continue
try:
series.setdefault(nom, {})[t] = float(v) if v else None
except ValueError:
texte.add(nom) # link, mode… : pas de courbe
return {n: dict(sorted(s.items())) for n, s in series.items()
if n not in texte and any(v is not None for v in s.values())}
def plage(mesures, du, au):
"""La plage lue : de du à au (exclu), sinon de la première mesure à la dernière, plus un pas."""
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
a = donnees.instant(du) if du else tous[0]
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2] if len(tous) > 1 else timedelta(hours=1))
return a, b
def courbes(station, du, au):
"""-> {A, B, T, plots} : T, les heures de chaque série, une fois (clé : le capteur, "" pour la caméra, « system: »
et son nom pour une métrique) ; plot : titre et traces (name, t, y, line, mode), sans plots ni capteurs vides."""
d = dossier(station)
mesures = donnees.charger(d)
if not mesures:
raise Refus(f"aucun export « advanced » pour {station}")
a, b = plage(mesures, du, au)
poses = [p for p in donnees.charger_camera(d) if a <= p["t"] < b]
heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly)
valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)}
refs, out = references(mesures, a, b), []
def par_capteur(colonnes):
for col, titre in colonnes:
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": COULEURS[i % len(COULEURS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate((s, valeurs(ms, col)) for s, ms in dans.items()) if any(v is not None for v in y)]
if traces:
out.append({"titre": titre, "traces": traces})
par_capteur(PLOTS)
if poses:
out.append({"titre": "Camera movement (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c),
"line": {"width": 1.2, "color": col}} for c, col in POSE]})
par_capteur(QUALITE)
T = {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}
systeme = metriques(d, a, b)
for nom in sorted(systeme, key=str.lower):
T["system:" + nom] = [heure(t) for t in systeme[nom]]
out.append({"titre": "System: " + nom, "traces": [{"name": nom, "t": "system:" + nom, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in systeme[nom].values()],
"line": {"width": 1.2, "color": COULEURS[0]}}]})
if not out:
raise Refus(f"aucune mesure de {station} sur cette plage")
return {"A": donnees.iso(a), "B": donnees.iso(b), "T": T, "plots": out}
# --- la page Data, étiquettes « Detectors » : les événements du journal, en lecture seule
HISTORIQUE = timedelta(days=3) # jours d'avant donnés aux détecteurs, comme categories.py (règle du 2026-10-24)
# ponytail: gardés jusqu'au redémarrage du serveur (une minute ou plus par plage) ; relancer après une séance de /detector-learner
@functools.lru_cache(maxsize=32)
def detecteurs(station, du, au, cibles=""):
"""-> les événements des détecteurs sur la plage, au format des étiquettes (debut, fin, categorie, description) ;
plus sorte, capteurs, ignore (zone grisée du journal). cibles : les capteurs gardés, séparés par des virgules (vide :
tous) ; les autres sont écartés avant les détecteurs, comme s'ils n'existaient pas."""
d = dossier(station)
tout = donnees.charger(d)
if cibles:
garde = set(cibles.split(","))
tout = {s: ms for s, ms in tout.items() if s in garde}
if not tout:
raise Refus(f"aucun export « advanced » pour {station}" + " avec ces cibles" * bool(cibles))
a, b = plage(tout, du, au)
mesures = {s: k for s, ms in tout.items() if (k := [m for m in ms if a - HISTORIQUE <= m["t"] < b])}
evs = [v for v in evenements(mesures, b, str(d)) if v["end"] >= donnees.iso(a)] if mesures else []
refs = {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"}
return [{"id": f"D-{i + 1}", "debut": v["start"], "fin": v["end"], "categorie": v["category"], "sorte": v["episodes"][0]["label"],
"description": f"{v['episodes'][0]['label']}. {v['text']}", "capteurs": v["sensors"], "ignore": v["ignore"],
"cibles": [s for s in v["sensors"] if s not in refs], "references": [s for s in v["sensors"] if s in refs],
"message": message(v["text"]), "action": action(v)}
for i, v in enumerate(evs)]
def message(texte):
"""Ce qui arrive : la première phrase du journal (detectors/categories.py, phrase), jusqu'à son « ; » ; la suite y dit quoi
en faire, sauf la phrase des sauts absorbés, gardée. ". " seulement : « 1.5× » ou « 0.30 px » ne coupent pas."""
meme = re.search(r" (The jumps? of .* same cause\.)$", texte)
return re.split(r"\. |; ", texte, maxsplit=1)[0].rstrip(".") + "." + (" " + meme.group(1) if meme else "")
# Quoi en faire : la colonne « Pour le client » de labeling/familles.md, par famille ; précisée par sorte (le label de l'épisode
# principal, avec son niveau) d'après les phrases du journal validées le 2026-10-24 (detectors/categories.py, phrase)
ACTION_FAMILLE = {
"Visibility": "Do not trust the curves in this period: this is not a movement.",
"Obstruction": "Ignore the curves of the hidden targets in this period.",
"Thermal displacement": "Normal, nothing to do.",
"Displacement": "To check: look at the images, then keep watching.",
"Target issue": "Act on the target (prism, mount); ignore its curve in the meantime.",
"No data": "The curves are missing in this period; its cause tells whether to act.",
}
ACTION_SORTE = {
"Poor visibility reduced": "Use the data in this period with care: they are less precise.",
"Heat shimmer": "Nothing to do: the small fast wiggles are not movement.",
"Camera thermal movement": "Nothing to do: this is not a movement of the structure.",
"Brief obstruction": "Ignore this single point on the curves.",
"Sudden jump, back to normal": "Look at the images: the cause is not established.",
"Lasting shift": "Check whether the structure moved: look at the images.",
"Jump, not back yet": "Check whether the structure moved: look at the images.",
"Large shift": "Check whether the structure moved: look at the images.",
"Slow drift": "Keep watching it.",
}
def action(v):
ep = v["episodes"][0]
return ACTION_SORTE.get(f"{ep['label']} {ep.get('level') or ''}".strip(), ACTION_SORTE.get(ep["label"])) \
or ACTION_FAMILLE.get(v["category"], "")
# --- les étiquettes (labeling/labeling.py, labeling/ids.py)
def fichier(station, source):
if source not in DOSSIERS:
raise Refus("dossier d'étiquettes inconnu")
dossier(station)
return ETIQUETTES / source / f"{station}.jsonl"
def lire(station, source):
f = fichier(station, source)
# split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
def attribuer(station, etiquettes):
"""labeling/ids.attribuer (D-131) : un id aux étiquettes qui n'en ont pas, le suivant de la station, en premier champ."""
n = max((int(e["id"].rsplit("-", 1)[1]) for e in etiquettes if "id" in e), default=0)
for e in etiquettes:
if "id" not in e:
n += 1
e["id"] = f"{station}-{n}"
if next(iter(e)) != "id":
reste = {k: v for k, v in e.items() if k != "id"}
ident = e["id"]
e.clear()
e.update({"id": ident}, **reste)
def _valide(corps, debut, fin):
description = (corps.get("description") or "").strip()
try:
vide = datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT)
except (TypeError, ValueError):
raise Refus("bornes illisibles (AAAA-MM-JJTHH:MMZ)") from None
if not description or vide:
raise Refus("texte vide ou plage vide")
c = corps.get("categorie") or ""
if c and c not in FAMILLES:
raise Refus("famille inconnue")
return description, c
def ajouter(corps):
station, source = corps.get("station"), corps.get("dossier", "manual")
f = fichier(station, source)
description, c = _valide(corps, corps.get("debut"), corps.get("fin"))
label = {"debut": corps["debut"], "fin": corps["fin"]} | ({"categorie": c} if c else {}) | {"description": description}
if source == "auto": # une étiquette automatique porte un id stable, le suivant de sa station (D-131)
attribuer(station, lire(station, "auto") + [label])
f.parent.mkdir(parents=True, exist_ok=True)
avant = f.read_bytes() if f.exists() else b"" # une ligne retirée à la main peut laisser le fichier sans fin de ligne
with open(f, "ab") as sortie:
sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
def modifier(corps):
avant = corps.get("avant") or {}
debut, fin = corps.get("debut", avant.get("debut")), corps.get("fin", avant.get("fin"))
description, c = _valide(corps, debut, fin)
label = dict.fromkeys(("id", "debut", "fin", "categorie")) | avant | {"debut": debut, "fin": fin, "categorie": c,
"description": description}
if label["id"] is None:
del label["id"]
if not c:
del label["categorie"]
label.pop("revue", None) # changée : à revoir par /review-labels (D-103)
return remplace(corps.get("station"), corps.get("dossier", "manual"), avant, label)
def supprimer(corps):
remplace(corps.get("station"), corps.get("dossier", "manual"), corps.get("avant"), None)
return corps.get("avant")
def remplace(station, source, avant, label):
"""Remplace l'étiquette avant par label (None : la retire), retrouvée par son contenu, pas par son rang : le fichier
a pu changer depuis le chargement de la page. Écrit à côté puis remplace : une coupure n'abîme pas le fichier."""
f = fichier(station, source)
lignes = f.read_text(encoding="utf-8").split("\n") if f.exists() else []
for i, ligne in enumerate(lignes):
if ligne.strip() and json.loads(ligne) == avant:
lignes[i:i + 1] = [] if label is None else [json.dumps(label, ensure_ascii=False)]
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("\n".join(lignes), encoding="utf-8")
os.replace(provisoire, f)
return label
raise Refus("cette étiquette n'est plus dans le fichier : recharger la page")