Family filter (Detectors and LLM) and target selection for the detectors (cibles parameter of /api/detecteurs, the other sensors discarded). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
293 lines
15 KiB
Python
293 lines
15 KiB
Python
"""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 []
|
|
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"]}
|
|
for i, v in enumerate(evs)]
|
|
|
|
|
|
# --- 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")
|