"""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")