Files
Support-Agent/app/serveur/station.py
T

289 lines
14 KiB
Python

"""Les données des pages Images et 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)}
# --- la page Images (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):
"""-> 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)."""
d = dossier(station)
tout = donnees.charger(d)
if not tout:
raise Refus(f"aucun export « advanced » pour {station}")
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")