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:
1 parent
8d5dc4a31c
commit
56f0c902d7
112 files changed
+13047
No files matched your search
@@ -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 `` 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)
|
||||
@@ -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__)
|
||||
@@ -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)
|
||||
@@ -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")
|
||||
Reference in new issue
Block a user