Files
Support-Agent/vues-deplacements/maquette/explore.py
T
maximeandClaude Opus 5.5 294e024e5a Move Displacements into a tab of the Explore mockup and document the session (D-055)
The jumps and trends now sit in a Displacements tab after Diagnosis
(#tab=displacements), no longer in a separate sidebar page; a click on
a row opens the Diagnosis tab on that target.

Documented: what the client looks at (jumps and trends, not errors,
handled upstream) in docs/displacement/domaine/ce-que-regarde-le-client.md;
the expert's reading of NORDEND in the case journey; the experimental
way of working in vues-deplacements/CLAUDE.md; D-055, the spec, the
note, the README and the project map.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 18:26:58 +02:00

208 lines
12 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) et Displacements (sauts et tendances, D-055) ;
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
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"))
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)
COLUMNS = ("error_value",) # 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, jours entre le premier et le dernier) 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[-1][0] - m[0][0]
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})
trend = find_trend(s, jumps)
if trend and abs(trend[0]) * trend[2] >= TREND_SIZE * swing and abs(trend[1]) >= TREND_STEADY:
trends.append({"target": name, "axis": axis, "slope": trend[0], "drift": trend[0] * trend[2],
"days": trend[2], "swing": swing, "jumps": len(jumps), "t": s[-1][0]})
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,
"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)