Files
Support-Agent/vues-deplacements/maquette/explore.py
T
maximeandClaude Opus 5.5 4ac95ae1ca Classify the morning journal into eight categories and validate plan points 1 to 10 (D-056)
- Event map regrouped into six families, 33 events including hypothetical ones, with the journal categories (section 4)
- categories.py turns detector episodes into categorised events: absorption of brief jumps, merging, catégorique phrases
- Journal tab: one "What happened" row coloured by family, cards, and an Images button playing the event's timelapse
- Plan: user-validated points marked, points 39 and 40 added; anomaly definition clarified in D-056

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 11:02:38 +02:00

235 lines
13 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Maquette de la page Explore, onglets View et Diagnosis (D-053, D-054), Displacements (sauts et tendances, D-055) et Journal ;
spec : vues-deplacements/maquette/spec.md.
Lit l'export « advanced » d'un dossier de station avec l'outil donnees.py de l'agent (positions, error_value) et son
export horaire (déplacements en mm), liste les images et les captures de la plateforme, puis remplit
explore_template.html. Écrit out/vues_deplacements_<STATION>.html et l'ouvre dans le navigateur.
Usage : python3 vues-deplacements/maquette/explore.py [dossier de station] (défaut : le cas NORDEND d'octobre 2026)
"""
import csv
import html
import json
import os
import statistics
import sys
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import quote
from zoneinfo import ZoneInfo
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
OUT = ROOT / "out"
DEFAULT = ROOT / "vues-deplacements" / "cas" / "2026-10_NORDEND" / "NORDEND"
sys.path.insert(0, str(ROOT / "src"))
sys.path.insert(0, str(ROOT / "agents" / "diagnostic" / "outils"))
sys.path.insert(0, str(ROOT / "vues-deplacements" / "journal"))
from common.page import AUTOSCALE_Y_JS, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
import donnees # noqa: E402 (lecture des exports, bibliothèque standard)
import categories # noqa: E402 (onglet Journal : détecteurs et classement en événements)
COLUMNS = ("error_value", "corr_x", "corr_y") # grandeurs de l'export « advanced » gardées pour la page, en plus de x, y
KINDS = ("global_ref", "ref", "target") # ordre des lignes : références de la compensation, local reference, cibles
MARGIN_PX = 150 # marge autour des capteurs, zoom de départ de l'image (spec §1)
HOURLY_TZ = ZoneInfo("Europe/Zurich") # horodatage de l'export horaire : heure suisse, sans fuseau (docs/domaine/colonnes-des-deplacements.md)
CAPTURES = {"time_series": ("01", "02", "03"), "advanced": ("04", "05")} # captures de cas/<cas>/plateforme/ par onglet
# Onglet Displacements (D-055, vues-deplacements/contexte/detection-d-anomalies.md) : sauts et tendances. Seuils provisoires,
# sans source, réglés sur les jeux de la note ; à revoir avec d'autres cas.
WINDOW = 24 # heures de part et d'autre d'un saut : une journée entière absorbe le cycle jour et nuit
STEP_H = 2 # un saut se fait en 2 h au plus (le pas de PR17 à 02:30 tombe entre deux moyennes horaires)
ABRUPT = 8 # brutal : changement sur STEP_H heures ≥ ABRUPT fois le changement habituel de la cible sur STEP_H heures
SIZE = 1.4 # notable : ce qui dure (médiane des 24 h après − des 24 h avant) ≥ SIZE fois l'amplitude journalière ;
# retour vertical de PR17 le 12/10 à 1,45, PR03 à 1,2 (seuil 3 avant : ce retour n'apparaissait pas)
TREND_DAYS = 5 # jours UTC (≥ 20 heures mesurées) au minimum pour une tendance
TREND_SIZE = 1 # tendance : dérive sur la période ≥ TREND_SIZE fois l'amplitude journalière…
TREND_STEADY = 0.6 # …et régulière : tau de Kendall des niveaux journaliers ≥ 0,6 (en valeur absolue)
TOGETHER_S = 6 * 3600 # sauts à moins de 6 h l'un de l'autre (de proche en proche) : un même événement
def hourly(path):
"""Export horaire -> déplacements en mm de chaque cible, heure par heure, en UTC (début de l'heure) ;
les références n'y sont pas."""
with open(path, newline="") as f:
rows = list(csv.DictReader(f))
if not rows:
return {"times": [], "sensors": {}}
num = lambda v: float(v) if v and v.strip() else None # noqa: E731
names = sorted(c[:-len("_vertical_displacement")] for c in rows[0] if c.endswith("_vertical_displacement"))
times = [datetime.fromisoformat(r["timestamp"]).replace(tzinfo=HOURLY_TZ) for r in rows]
return {"times": [donnees.iso(t) for t in times],
"sensors": {n: {"h": [num(r[f"{n}_horizontal_displacement"]) for r in rows],
"v": [num(r[f"{n}_vertical_displacement"]) for r in rows]} for n in names}}
def daily(s):
"""[(t, v)…] -> {jour UTC: [v…]}, jours d'au moins 20 heures mesurées."""
days = {}
for t, v in s:
days.setdefault(t[:10], []).append(v)
return {d: vs for d, vs in days.items() if len(vs) >= 20}
def find_jumps(s, swing):
"""Sauts d'une série [(t, v)…] : un changement brutal sur STEP_H heures qui dure (même sens, au moins sa moitié et
SIZE fois l'amplitude journalière, sur WINDOW heures) ; le plus net par ±WINDOW heures. -> [(index du début, saut)]"""
d = [s[i + STEP_H][1] - s[i][1] for i in range(len(s) - STEP_H)]
usual = statistics.median(abs(x) for x in d)
med = lambda a, b: statistics.median(v for _, v in s[a:b]) # noqa: E731
c = {}
for i in range(WINDOW - 1, len(s) - STEP_H - WINDOW + 1):
if not usual or abs(d[i]) < ABRUPT * usual:
continue
lasting = med(i + STEP_H, i + STEP_H + WINDOW) - med(i - WINDOW + 1, i + 1)
if d[i] * lasting > 0 and abs(lasting) >= max(abs(d[i]) / 2, SIZE * swing):
c[i] = lasting
found = []
while c:
i = max(c, key=lambda i: abs(c[i]))
found.append((i, c[i]))
c = {j: x for j, x in c.items() if abs(j - i) >= WINDOW}
return sorted(found)
def find_trend(s, jumps):
"""Tendance d'une série, sauts retirés pour le calcul seulement : pente de Theil-Sen (mm par jour) et tau de Kendall
des médianes journalières. -> (pente, tau, [(jour, médiane)…], ordonnée à l'origine de la droite) ou None sous
TREND_DAYS jours."""
kept = [(t, v - sum(j for i, j in jumps if k >= i + STEP_H)) for k, (t, v) in enumerate(s)
if not any(i < k < i + STEP_H for i, _ in jumps)]
m = sorted((datetime.fromisoformat(d).toordinal(), statistics.median(vs)) for d, vs in daily(kept).items())
if len(m) < TREND_DAYS:
return None
pairs = [(a, b) for k, a in enumerate(m) for b in m[k + 1:]]
slope = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in pairs)
tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in pairs) / len(pairs)
return slope, tau, m, statistics.median(v - slope * x for x, v in m)
def noon(day):
"""Jour (ordinal) -> son midi UTC, où la page place le niveau du jour."""
return donnees.iso(datetime.fromordinal(day).replace(hour=12, tzinfo=timezone.utc))
def trend_line(s, jumps, m, slope, a):
"""Droite de Theil-Sen de find_trend, du midi du premier jour à celui du dernier, sauts remis : alignée sur la courbe
brute, elle marche d'un saut à chaque saut mis de côté. -> [[instant, mm]…]"""
steps = [(s[i][0], s[i + STEP_H][0], j) for i, j in jumps]
t0, t1 = noon(m[0][0]), noon(m[-1][0])
def at(t):
d = datetime.fromisoformat(t)
return a + slope * (d.toordinal() + (d.hour - 12) / 24 + d.minute / 1440) + sum(j for _, e, j in steps if e <= t)
return [[t, at(t)] for t in [t0, *(t for b, e, _ in steps if t0 < b and e < t1 for t in (b, e)), t1]]
def regime_changes(hr):
"""Déplacements horaires (sortie de hourly) -> (événements de sauts, tendances), données inchangées. Pour chaque cible
et chaque axe : tous les sauts brutaux qui durent (find_jumps), puis la tendance du reste (find_trend), gardée si la
dérive sur la période dépasse TREND_SIZE amplitudes journalières et va régulièrement dans le même sens. Des sauts à
moins de TOGETHER_S de proche en proche font un seul événement : plusieurs cibles qui sautent ensemble ne sont pas
plusieurs anomalies (règle du mode commun, CLAUDE.md)."""
found, trends = [], []
for name, axes in hr["sensors"].items():
for key, axis in (("h", "horizontal"), ("v", "vertical")):
# ponytail: fenêtres comptées en heures mesurées, un trou les allonge
s = [(t, v) for t, v in zip(hr["times"], axes[key]) if v is not None]
if len(s) < 3 * WINDOW:
continue
swings = [max(vs) - min(vs) for vs in daily(s).values()]
swing = statistics.median(swings) if swings else 0
if not swing:
continue
jumps = find_jumps(s, swing)
last = statistics.median(v for _, v in s[-WINDOW:])
for i, j in jumps:
before = statistics.median(v for _, v in s[i - WINDOW + 1:i + 1])
found.append({"target": name, "axis": axis, "t": s[i][0], "t2": s[i + STEP_H][0], "jump": j,
"swing": swing, "left": last - before, "before": before, "after": before + j,
"w0": s[i - WINDOW + 1][0], "w1": s[i + STEP_H + WINDOW - 1][0]}) # fenêtres des niveaux
trend = find_trend(s, jumps)
if not trend:
continue
slope, tau, m, a = trend
days = m[-1][0] - m[0][0]
if abs(slope) * days >= TREND_SIZE * swing and abs(tau) >= TREND_STEADY:
trends.append({"target": name, "axis": axis, "slope": slope, "drift": slope * days, "days": days,
"swing": swing, "jumps": len(jumps), "t": s[-1][0], "line": trend_line(s, jumps, m, slope, a),
"levels": [[noon(datetime.fromisoformat(d).toordinal()), statistics.median(vs)]
for d, vs in sorted(daily(s).items())]})
at = lambda f: datetime.fromisoformat(f["t"]).timestamp() # noqa: E731
events = []
for f in sorted(found, key=lambda f: f["t"]):
if events and at(f) - at(events[-1]["jumps"][-1]) <= TOGETHER_S:
events[-1]["jumps"].append(f)
else:
events.append({"jumps": [f]})
for e in events:
e["start"], e["end"] = e["jumps"][0]["t"], e["jumps"][-1]["t2"]
e["targets"] = sorted({f["target"] for f in e["jumps"]})
e["jumps"].sort(key=lambda f: abs(f["jump"]) / f["swing"], reverse=True)
return events, sorted(trends, key=lambda f: abs(f["drift"]) / f["swing"], reverse=True)
def url(path):
"""Chemin -> URL relative depuis out/, où la page est écrite."""
return quote(Path(os.path.relpath(path, OUT)).as_posix())
def build(folder):
"""Dossier de station -> données de la page ; quitte avec un message s'il n'a pas d'export « advanced »."""
files = donnees.trouver(str(folder))
if not files["advanced"]:
sys.exit(f"Pas d'export « advanced » dans {folder}")
mesures = donnees.charger(str(folder))
minute = lambda t: t.replace(second=0, microsecond=0) # noqa: E731 (instants à la minute, comme donnees.iso)
instants = sorted({minute(m["t"]) for ms in mesures.values() for m in ms})
col = {t: j for j, t in enumerate(instants)}
order = lambda s: (KINDS.index(mesures[s][0]["pattern_type"]) if mesures[s][0]["pattern_type"] in KINDS # noqa: E731
else len(KINDS), s)
sensors = []
for name in sorted(mesures, key=order):
ms = mesures[name]
row = {c: [None] * len(instants) for c in ("x", "y") + COLUMNS}
for m in ms:
for c in row:
row[c][col[minute(m["t"])]] = m[c]
xs, ys = [v for v in row["x"] if v is not None], [v for v in row["y"] if v is not None]
sensors.append({"name": name, "kind": ms[0]["pattern_type"], "threshold": ms[0]["error_threshold"],
"x": row["x"], "y": row["y"],
"home": [statistics.median(xs), statistics.median(ys)] if xs and ys else None,
"values": {c: row[c] for c in COLUMNS}})
homes = [s["home"] for s in sensors if s["home"]]
view = {a: [min(h[k] for h in homes) - MARGIN_PX, max(h[k] for h in homes) + MARGIN_PX]
for k, a in enumerate(("x", "y"))} if homes else None
images = sorted(({"t": donnees.iso(t), "src": url(p)} for p in files["images"] if (t := donnees.heure_image(p))),
key=lambda im: im["t"])
plateforme = Path(folder).resolve().parent / "plateforme"
captures = {tab: [url(p) for n in prefixes for p in sorted(plateforme.glob(f"{n}_*"))[:1]]
for tab, prefixes in CAPTURES.items()}
hr = hourly(files["horaire"][0]) if files["horaire"] else {"times": [], "sensors": {}}
regime, trends = regime_changes(hr)
return {"platform": Path(files["advanced"][0]).name.split("_advanced_")[0], "times": [donnees.iso(t) for t in instants],
"sensors": sensors, "images": images, "view": view, "captures": captures,
"folder": Path(os.path.relpath(Path(folder).resolve(), ROOT)).as_posix(), # pour la demande à l'agent
"hourly": hr, "regime": regime, "trends": trends, "journal": categories.evenements(mesures),
"rules": {"abrupt": ABRUPT, "size": SIZE, "trend_size": TREND_SIZE, "trend_days": TREND_DAYS}}
def page(folder):
"""Dossier de station -> chemin de la page écrite dans out/."""
data = build(folder)
text = (HERE / "explore_template.html").read_text()
text = text.replace("<!--PLATFORM-->", html.escape(data["platform"]))
text = text.replace("/*DATA*/null", json.dumps(data).replace("</", "<\\/"))
text = text.replace("/*AUTOSCALE*/", AUTOSCALE_Y_JS.replace("'{plot_id}'", "plotId")) # ordonnée recalée (D-013)
OUT.mkdir(exist_ok=True)
out = OUT / f"vues_deplacements_{Path(folder).resolve().name}.html"
out.write_text(text)
return out
if __name__ == "__main__":
out = page(sys.argv[1] if len(sys.argv) > 1 else DEFAULT)
print(out)
open_html(out)