332 lines
17 KiB
Python
332 lines
17 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 []
|
||
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")
|