2026-11-13 16:24:49 +01:00
|
|
|
"""Un batch d'Optimizer : un jour UTC (24 h), toutes les stations de data/.
|
|
|
|
|
|
|
|
|
|
1. Les détecteurs (detectors/, categories.events, avec 3 jours d'historique) sur le jour ; leurs événements deviennent
|
|
|
|
|
des étiquettes coupées au jour, batches/<jour>/detecteurs/<STATION>.jsonl, copiées dans batches/<jour>/verite/ ; une
|
|
|
|
|
figure par station, batches/<jour>/figures/<STATION>.png ; le résumé pour le scanner, batches/<jour>/detecteurs.md.
|
|
|
|
|
2. Le scan : l'agent scanner (.claude/agents/scanner.md, par claude -p) note les irrégularités dans
|
|
|
|
|
batches/<jour>/rapport.md et les corrige dans verite/ ; puis la vérité est contrôlée.
|
2026-11-14 15:16:57 +01:00
|
|
|
3. L'amélioration, si le scanner a corrigé une station et la vérité est sans erreur : /detectors:wf-improve (le plugin
|
|
|
|
|
du dépôt detectors), une seule séance sur les stations corrigées, la vérité pour étiquettes, le rapport pour contexte ;
|
|
|
|
|
ses sorties, son bilan (summary.md) et les scripts de ses agents (tools/) dans batches/<jour>/improve/.
|
2026-11-13 16:24:49 +01:00
|
|
|
|
|
|
|
|
Usage : python3 batch.py [--jour AAAA-MM-JJ] [--stations A,B] [--sans-scan]
|
2026-11-14 15:16:57 +01:00
|
|
|
Jour par défaut : hier (UTC). Une étape faite ne se refait pas (le dossier du batch existe, rapport.md existe,
|
|
|
|
|
improve/summary.md existe) : relancer après --sans-scan fait le reste ; supprimer batches/<jour>/ pour tout refaire.
|
2026-11-13 16:24:49 +01:00
|
|
|
Toute heure est en UTC.
|
|
|
|
|
"""
|
|
|
|
|
import argparse
|
2026-11-14 15:16:57 +01:00
|
|
|
import bisect
|
2026-11-13 16:24:49 +01:00
|
|
|
import json
|
|
|
|
|
import os
|
|
|
|
|
import shutil
|
|
|
|
|
import statistics
|
|
|
|
|
import subprocess
|
|
|
|
|
import sys
|
2026-11-14 15:45:45 +01:00
|
|
|
import tempfile
|
2026-11-13 16:24:49 +01:00
|
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
|
from pathlib import Path
|
|
|
|
|
|
|
|
|
|
RACINE = Path(__file__).resolve().parent
|
|
|
|
|
try:
|
|
|
|
|
import matplotlib
|
|
|
|
|
except ImportError: # les figures demandent matplotlib, dans .venv
|
|
|
|
|
venv = RACINE / ".venv" / "bin" / "python"
|
|
|
|
|
if not venv.exists():
|
|
|
|
|
sys.exit("matplotlib manque : python3 -m venv .venv && .venv/bin/pip install matplotlib")
|
|
|
|
|
os.execv(venv, [str(venv), *sys.argv])
|
|
|
|
|
matplotlib.use("Agg")
|
|
|
|
|
import matplotlib.pyplot as plt # noqa: E402
|
|
|
|
|
|
|
|
|
|
sys.path.insert(0, str(RACINE / "detectors" / "scripts"))
|
|
|
|
|
import categories # noqa: E402
|
|
|
|
|
from data import is_reference, iso, load, load_temperature, parse_time, rejected # noqa: E402
|
|
|
|
|
|
|
|
|
|
DONNEES, BATCHES = RACINE / "data", RACINE / "batches"
|
|
|
|
|
HISTORIQUE = timedelta(days=3) # comme categories.py et wf-improve : sans historique, un saut réel passe pour un retour
|
|
|
|
|
FAMILLES = list(categories.CATEGORIES)
|
|
|
|
|
COULEURS = dict(zip(FAMILLES, ("tab:blue", "tab:orange", "tab:purple", "tab:red", "tab:gray", "tab:green")))
|
|
|
|
|
CLES = {"id", "debut", "fin", "categorie", "description"}
|
|
|
|
|
CALME = 5 # bruits propres : en deçà, une courbe est calme (comme le --k 5 des outils de lecture de Diagnostic-App)
|
|
|
|
|
PAS = 0.25 # heures : le pas de la figure, 15 min, la cadence de la plupart des stations
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def capteurs(v):
|
|
|
|
|
s = v["sensors"]
|
2026-11-14 15:47:51 +01:00
|
|
|
return "tous les capteurs" if not s else ", ".join(s) if len(s) <= 12 else f"{len(s)} capteurs" # 12 : un groupe se reconnaît
|
2026-11-13 16:24:49 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
def etiquettes(station, mesures, d):
|
2026-11-14 15:16:57 +01:00
|
|
|
"""Les événements des détecteurs qui touchent le jour, en étiquettes coupées au jour. Les détecteurs ne lisent rien
|
|
|
|
|
après minuit, comme score.py de wf-improve : la vérité ne diffère des détecteurs que par les corrections du scanner
|
|
|
|
|
(avec les heures d'après, leurs statistiques changent sur tout le jour, essai du 2026-11-05) ; un saut du soir qui
|
|
|
|
|
revient après minuit reste « not back yet »."""
|
2026-11-13 16:24:49 +01:00
|
|
|
b, h, jour = d + timedelta(days=1), d - HISTORIQUE, iso(d)[:10]
|
|
|
|
|
morceau = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
|
|
|
|
|
evs = [v for v in categories.events(morceau, b, str(DONNEES / station)) if v["end"] > iso(d)]
|
2026-11-14 15:16:57 +01:00
|
|
|
# un événement va du premier au dernier point touché, une étiquette de la mesure d'avant à celle d'après (les règles
|
|
|
|
|
# d'étiquetage, score.py) ; un No data va déjà d'une mesure à l'autre ; sans mesure d'après dans le jour : minuit ;
|
2026-11-14 15:22:25 +01:00
|
|
|
# commencé la veille : la dernière mesure d'avant minuit (coupée à 00:00, la mesure de minuit serait une borne), au plus
|
|
|
|
|
# tôt la veille à 00:00 (un No data de plusieurs jours)
|
2026-11-14 15:16:57 +01:00
|
|
|
ts = sorted({iso(m["t"]) for ms in morceau.values() for m in ms})
|
|
|
|
|
avant = lambda t: ts[i - 1] if (i := bisect.bisect_left(ts, t)) else t # noqa: E731
|
|
|
|
|
apres = lambda t: ts[i] if (i := bisect.bisect_right(ts, t)) < len(ts) else iso(b) # noqa: E731
|
|
|
|
|
for v in evs:
|
|
|
|
|
if v["category"] != "No data":
|
|
|
|
|
v["start"], v["end"] = avant(v["start"]), apres(v["end"])
|
2026-11-14 15:22:25 +01:00
|
|
|
veille = iso(d - timedelta(days=1))
|
|
|
|
|
return [{"id": f"{station}-{jour}-D{i}", "debut": max(v["start"], avant(iso(d)), veille), "fin": min(v["end"], iso(b)),
|
2026-11-13 16:24:49 +01:00
|
|
|
"categorie": v["category"],
|
|
|
|
|
"description": f"Détecteurs : {v['episodes'][0]['label']}, {capteurs(v)}{', grisé' if v['ignore'] else ''}. "
|
|
|
|
|
f"{v['text']}"} for i, v in enumerate(evs, 1)]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def courte(e):
|
|
|
|
|
"""Une ligne du résumé : id court, heures, famille, variété et capteurs."""
|
|
|
|
|
quoi = e["description"].removeprefix("Détecteurs : ").split(". ")[0]
|
2026-11-14 15:16:57 +01:00
|
|
|
jour = e["id"].rsplit("-", 1)[0][-10:]
|
|
|
|
|
debut = e["debut"][11:16] + (" (la veille)" if e["debut"][:10] < jour else "")
|
|
|
|
|
fin = "24:00" if e["fin"][:10] > jour else e["fin"][11:16] # coupée au jour : minuit d'après, 24:00
|
|
|
|
|
return f"- {e['id'].rsplit('-', 1)[1]} {debut} → {fin} {e['categorie']} : {quoi}"
|
2026-11-13 16:24:49 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
def coupe(points, pas):
|
|
|
|
|
"""[(heure, valeur)] -> la même liste, un NaN dans chaque trou plus long qu'un pas et demi (la courbe s'y interrompt)."""
|
|
|
|
|
out = []
|
|
|
|
|
for p in points:
|
|
|
|
|
if out and p[0] - out[-1][0] > 1.5 * pas:
|
|
|
|
|
out.append((out[-1][0] + pas, float("nan")))
|
|
|
|
|
out.append(p)
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def cadence(ts):
|
|
|
|
|
"""[datetime] -> l'écart médian entre deux, en heures, jamais moins que le pas de la figure (une station qui mesure
|
|
|
|
|
par rafales, 3 mesures à 1 min toutes les 15 min, a une cadence de 15 min)."""
|
|
|
|
|
e = [(y - x).total_seconds() / 3600 for x, y in zip(ts, ts[1:])]
|
|
|
|
|
return max(statistics.median(e) if e else PAS, PAS)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def figure(station, mesures, temperature, labels, d, chemin):
|
|
|
|
|
"""La figure du jour, par pas de PAS : étiquettes par famille ; corr_x, corr_y des cibles (écart à leur médiane du
|
|
|
|
|
jour, en bruits propres, écrêté ; dans chaque pas, l'écart le plus grand : un pic d'une mesure reste) ; rejets et
|
|
|
|
|
manques ; température du boîtier et error_value / seuil. Les références n'y sont pas : certaines valent 0 par
|
|
|
|
|
construction, en bruits leur courbe n'a pas de sens. Chaque capteur a sa cadence (une station peut en mêler deux).
|
2026-11-14 15:16:57 +01:00
|
|
|
Rend (cibles, références, la cadence en mots, instants)."""
|
2026-11-13 16:24:49 +01:00
|
|
|
b = d + timedelta(days=1)
|
|
|
|
|
heure = lambda t: (t - d).total_seconds() / 3600 # noqa: E731
|
|
|
|
|
case = lambda t: int(heure(t) / PAS) # noqa: E731
|
|
|
|
|
centre = lambda k: (k + 0.5) * PAS # noqa: E731
|
|
|
|
|
cases = range(round(24 / PAS))
|
|
|
|
|
jour = {s: k for s, ms in mesures.items() if (k := [m for m in ms if d <= m["t"] < b])}
|
|
|
|
|
actifs = [s for s, ms in mesures.items() if ms[-1]["t"] >= d - HISTORIQUE] # un capteur muet tout le jour manque
|
|
|
|
|
ps = {s: cadence([m["t"] for m in mesures[s] if d - HISTORIQUE <= m["t"] < b]) for s in actifs}
|
|
|
|
|
cibles = {s: ms for s, ms in jour.items() if not is_reference(mesures[s])}
|
|
|
|
|
instants = sorted({m["t"] for ms in jour.values() for m in ms})
|
|
|
|
|
natif = [(y - x).total_seconds() / 60 for x, y in zip(instants, instants[1:])]
|
|
|
|
|
|
|
|
|
|
fig, ax = plt.subplots(5, 1, figsize=(14, 10), sharex=True, gridspec_kw={"height_ratios": [1.4, 3, 3, 1, 1]})
|
|
|
|
|
fig.suptitle(f"{station} — {iso(d)[:10]} (UTC) — {len(cibles)} cibles (les références ne sont pas tracées) — "
|
|
|
|
|
f"tracé par pas de {round(PAS * 60)} min", fontsize=11)
|
|
|
|
|
for e in labels: # 0 : les étiquettes, une ligne par famille, alignées sur les courbes
|
|
|
|
|
y = FAMILLES.index(e["categorie"]) if e["categorie"] in FAMILLES else len(FAMILLES) - 1
|
|
|
|
|
x0, x1 = heure(parse_time(e["debut"])), heure(parse_time(e["fin"]))
|
|
|
|
|
ax[0].barh(y, max(x1 - x0, 0.15), left=x0, height=0.8, color=COULEURS.get(e["categorie"], "black"), alpha=0.6)
|
|
|
|
|
ax[0].text(x0 + 0.05, y, e["id"].rsplit("-", 1)[1], va="center", fontsize=7)
|
|
|
|
|
ax[0].set_yticks(range(len(FAMILLES)), FAMILLES, fontsize=8)
|
|
|
|
|
ax[0].set_ylim(len(FAMILLES) - 0.5, -0.5)
|
|
|
|
|
|
|
|
|
|
for a, col in ((ax[1], "corr_x"), (ax[2], "corr_y")): # 1, 2 : chaque cible, en bruits, autour de sa médiane
|
|
|
|
|
ecarts = {}
|
|
|
|
|
for s, ms in cibles.items():
|
|
|
|
|
v = [m[col] for m in ms if m[col] is not None]
|
|
|
|
|
hist = [m[col] for m in mesures[s] if d - HISTORIQUE <= m["t"] < b and m[col] is not None]
|
|
|
|
|
bruit = statistics.median(abs(y - x) for x, y in zip(hist, hist[1:])) if len(hist) > 2 else 0
|
|
|
|
|
if not v or bruit <= 0: # bruit propre : médiane des écarts entre deux mesures, sur le jour et son historique
|
|
|
|
|
continue
|
|
|
|
|
med, pire = statistics.median(v), {}
|
2026-11-14 15:16:57 +01:00
|
|
|
for m in ms: # dans chaque pas, l'écart le plus grand ; NaN (rejetée) seulement s'il n'y a rien d'autre
|
|
|
|
|
x, k = float("nan") if m[col] is None else (m[col] - med) / bruit, case(m["t"])
|
|
|
|
|
if k not in pire or x == x and not abs(pire[k]) >= abs(x):
|
|
|
|
|
pire[k] = x
|
2026-11-13 16:24:49 +01:00
|
|
|
ecarts[s] = coupe([(centre(k), pire[k]) for k in sorted(pire)], ps[s])
|
|
|
|
|
tous = sorted(abs(x) for v in ecarts.values() for _, x in v if x == x)
|
|
|
|
|
lim = max(tous[int(0.99 * (len(tous) - 1))] * 1.2, 2 * CALME) if tous else 2 * CALME # ponytail: 99e centile
|
2026-11-14 15:16:57 +01:00
|
|
|
bride = lambda x: x if x != x else max(-lim, min(lim, x)) # noqa: E731 — NaN reste NaN : la courbe s'interrompt
|
2026-11-13 16:24:49 +01:00
|
|
|
for s, v in ecarts.items():
|
|
|
|
|
a.plot([t for t, _ in v], [bride(x) for _, x in v], lw=0.7)
|
|
|
|
|
hors = sorted(((max(abs(x) for _, x in v if x == x), s) for s, v in ecarts.items()), reverse=True)
|
|
|
|
|
for _, s in [(m, s) for m, s in hors if m > CALME][:5]: # le nom des cibles qui sortent le plus du calme
|
|
|
|
|
t, x = max(((t, x) for t, x in ecarts[s] if x == x), key=lambda p: abs(p[1]))
|
|
|
|
|
a.annotate(s, (t, bride(x)), fontsize=7)
|
|
|
|
|
for y in (-CALME, CALME):
|
|
|
|
|
a.axhline(y, color="0.4", ls=":", lw=0.8)
|
|
|
|
|
a.set_ylim(-1.05 * lim, 1.05 * lim)
|
|
|
|
|
a.set_ylabel(f"{col}, en bruits propres\n(écart à la médiane du jour ;\npointillé : ±{CALME}, le calme ;"
|
|
|
|
|
f"\nécrêté à ±{lim:.0f})", fontsize=8)
|
|
|
|
|
|
|
|
|
|
par = {s: [m for m in mesures[s] if d <= m["t"] < b] for s in actifs} # 3 : rejets et manques par pas
|
|
|
|
|
trous = {} # par capteur, ses trous plus longs qu'un pas et demi de sa cadence, en heures
|
|
|
|
|
for s in actifs:
|
|
|
|
|
hs = [0.0, *(heure(m["t"]) for m in par[s]), 24.0]
|
|
|
|
|
trous[s] = [(u, v) for u, v in zip(hs, hs[1:]) if v - u > 1.5 * ps[s]]
|
2026-11-14 15:16:57 +01:00
|
|
|
rejs = [{s for s in actifs for m in par[s] if case(m["t"]) == k and rejected(m)} for k in cases]
|
|
|
|
|
refr = [sum(1 for s in r if is_reference(mesures[s])) for r in rejs] # une référence rejetée : toutes les cibles bougent
|
|
|
|
|
rej = [len(r) for r in rejs]
|
2026-11-13 16:24:49 +01:00
|
|
|
manq = [sum(1 for s in actifs if any(u < centre(k) < v for u, v in trous[s])) for k in cases]
|
|
|
|
|
x = [centre(k) for k in cases]
|
2026-11-14 15:16:57 +01:00
|
|
|
ax[3].bar(x, refr, width=PAS, color="black", label="références rejetées")
|
|
|
|
|
ax[3].bar(x, [r - f for r, f in zip(rej, refr)], width=PAS, bottom=refr, color="tab:red", label="cibles rejetées")
|
2026-11-13 16:24:49 +01:00
|
|
|
ax[3].bar(x, manq, width=PAS, bottom=rej, color="0.6", label="manquantes")
|
|
|
|
|
bords = [0.0, *(heure(t) for t in instants), 24.0]
|
|
|
|
|
station_pas = cadence(instants)
|
|
|
|
|
for x0, x1 in zip(bords, bords[1:]): # les trous : aucune mesure d'aucun capteur
|
|
|
|
|
if x1 - x0 > 1.5 * station_pas:
|
|
|
|
|
ax[3].axvspan(x0, x1, color="0.3", alpha=0.25, hatch="//")
|
|
|
|
|
ax[3].set_ylim(0, max(len(actifs), 1))
|
2026-11-14 15:16:57 +01:00
|
|
|
ax[3].set_ylabel("capteurs\nrejetés, manquants\n(noir : références ;\nhachuré : rien)", fontsize=8)
|
2026-11-13 16:24:49 +01:00
|
|
|
ax[3].legend(fontsize=7, loc="upper right")
|
|
|
|
|
|
|
|
|
|
temp = [(heure(t), c) for t, c in temperature if d <= t < b] # 4 : température et error_value / seuil
|
|
|
|
|
if temp:
|
|
|
|
|
ax[4].plot(*zip(*temp), color="tab:red", lw=1)
|
|
|
|
|
ax[4].set_ylabel("température\nboîtier [°C]", fontsize=8, color="tab:red")
|
|
|
|
|
rapports = {}
|
|
|
|
|
for s in actifs:
|
|
|
|
|
for m in par[s]:
|
2026-11-14 15:47:51 +01:00
|
|
|
if m["error_value"] is not None and m["error_threshold"] and not rejected(m): # un rejeté est au-dessus par
|
|
|
|
|
# définition, parfois figé : la moitié de la scène cachée faisait un pic de toute la scène (essai du 06)
|
2026-11-13 16:24:49 +01:00
|
|
|
rapports.setdefault(case(m["t"]), []).append(m["error_value"] / m["error_threshold"])
|
|
|
|
|
a2 = ax[4].twinx()
|
|
|
|
|
if rapports:
|
|
|
|
|
a2.plot(*zip(*coupe([(centre(k), statistics.median(r)) for k, r in sorted(rapports.items())], station_pas)),
|
|
|
|
|
color="tab:blue", lw=1)
|
|
|
|
|
a2.axhline(1, color="tab:blue", ls=":", lw=0.8)
|
2026-11-14 15:47:51 +01:00
|
|
|
a2.set_ylabel("error_value / seuil\n(médiane des capteurs\nacceptés)", fontsize=8, color="tab:blue")
|
2026-11-13 16:24:49 +01:00
|
|
|
|
|
|
|
|
ax[-1].set_xlim(0, 24)
|
|
|
|
|
ax[-1].set_xticks(range(0, 25, 2), [f"{h:02d}:00" for h in range(0, 25, 2)])
|
|
|
|
|
ax[-1].set_xticks(range(25), minor=True)
|
|
|
|
|
for a in ax:
|
|
|
|
|
a.grid(alpha=0.3, which="both")
|
|
|
|
|
fig.tight_layout()
|
|
|
|
|
fig.savefig(chemin, dpi=100)
|
|
|
|
|
plt.close(fig)
|
2026-11-14 15:16:57 +01:00
|
|
|
refs = sorted(s for s in jour if s not in cibles)
|
|
|
|
|
pas = round(statistics.median(natif)) if natif else 0
|
|
|
|
|
heures = {}
|
|
|
|
|
for t in instants:
|
|
|
|
|
h = t.replace(minute=0, second=0, microsecond=0)
|
|
|
|
|
heures[h] = heures.get(h, 0) + 1
|
|
|
|
|
cycle = round(60 / statistics.median(heures.values())) if heures else 0
|
|
|
|
|
mots = f"une mesure toutes les {pas} min" + (f", par rafales (en moyenne une toutes les {cycle} min)"
|
|
|
|
|
if cycle > 2 * pas else "")
|
|
|
|
|
return len(cibles), f"{len(refs)} références" + (f" ({', '.join(refs)})" if refs else ""), mots, len(instants)
|
2026-11-13 16:24:49 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
def detecteurs(dossier, d, stations):
|
|
|
|
|
"""L'étape 1, dans un dossier provisoire renommé à la fin : un batch interrompu ne passe pas pour fait."""
|
|
|
|
|
tmp = dossier.with_name(dossier.name + ".tmp")
|
|
|
|
|
shutil.rmtree(tmp, ignore_errors=True)
|
|
|
|
|
for sous in ("detecteurs", "verite", "figures"):
|
|
|
|
|
(tmp / sous).mkdir(parents=True)
|
|
|
|
|
jour, resume, muettes = iso(d)[:10], [], []
|
|
|
|
|
for station in stations:
|
|
|
|
|
mesures = load(str(DONNEES / station))
|
|
|
|
|
if not any(d - HISTORIQUE <= m["t"] < d + timedelta(days=1) for ms in mesures.values() for m in ms):
|
|
|
|
|
muettes.append(station)
|
|
|
|
|
continue
|
|
|
|
|
labels = etiquettes(station, mesures, d)
|
|
|
|
|
texte = "".join(json.dumps(e, ensure_ascii=False) + "\n" for e in labels)
|
|
|
|
|
for sous in ("detecteurs", "verite"):
|
|
|
|
|
(tmp / sous / f"{station}.jsonl").write_text(texte, encoding="utf-8")
|
|
|
|
|
nc, nr, pas, n = figure(station, mesures, load_temperature(str(DONNEES / station)), labels, d,
|
|
|
|
|
tmp / "figures" / f"{station}.png")
|
2026-11-14 15:16:57 +01:00
|
|
|
resume += [f"## {station}", "", f"figures/{station}.png ; {nc} cibles, {nr} ; {pas}, {n} instants mesurés.", "",
|
|
|
|
|
*map(courte, labels),
|
2026-11-13 16:24:49 +01:00
|
|
|
*([] if labels else ["- aucune étiquette"]), ""]
|
|
|
|
|
print(f"{station} : {len(labels)} étiquettes", flush=True)
|
|
|
|
|
entete = [f"# Les détecteurs, {jour} (UTC)", "",
|
|
|
|
|
"Une section par station : sa figure, ses capteurs, puis les étiquettes des détecteurs (id court, heures, "
|
|
|
|
|
"famille : variété, capteurs ; grisé : non montré au client). Le détail : verite/<STATION>.jsonl.", ""]
|
|
|
|
|
fin = [f"Sans mesure du {iso(d - HISTORIQUE)[:10]} au {jour} : {', '.join(muettes)}.", ""] if muettes else []
|
|
|
|
|
(tmp / "detecteurs.md").write_text("\n".join(entete + resume + fin), encoding="utf-8")
|
|
|
|
|
tmp.rename(dossier)
|
|
|
|
|
|
|
|
|
|
|
2026-11-14 15:16:57 +01:00
|
|
|
def claude(dossier, nom, args):
|
|
|
|
|
"""claude -p avec args, son flux dans <dossier>/<nom>.jsonl ; imprime sa réponse et son coût. L'abonnement Claude
|
|
|
|
|
seulement, jamais une clé d'API : sans elles dans l'environnement, claude prend la connexion claude.ai ; si son
|
|
|
|
|
message d'ouverture dit une autre source (apiKeyHelper…), ou s'il répond sans l'avoir dit, il est arrêté. Les
|
|
|
|
|
réglages du poste (hooks, plugins, serveurs MCP de l'utilisateur) restent dehors : un agent du batch ne voit que le
|
|
|
|
|
projet et ce que args lui donne."""
|
2026-11-13 16:26:17 +01:00
|
|
|
env = {k: v for k, v in os.environ.items() if k not in ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN")}
|
2026-11-14 15:16:57 +01:00
|
|
|
chemin, source = dossier / f"{nom}.jsonl", None
|
|
|
|
|
with open(chemin, "w", encoding="utf-8", buffering=1) as flux: # ligne à ligne : le flux se suit pendant la séance
|
|
|
|
|
p = subprocess.Popen(["claude", "-p", *args, "--permission-mode", "acceptEdits", "--setting-sources",
|
|
|
|
|
"project,local", "--strict-mcp-config", "--output-format", "stream-json", "--verbose"],
|
|
|
|
|
cwd=RACINE, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
|
2026-11-13 16:26:17 +01:00
|
|
|
for ligne in p.stdout:
|
|
|
|
|
flux.write(ligne)
|
2026-11-14 15:16:57 +01:00
|
|
|
if '"subtype":"init"' in ligne and source is None:
|
|
|
|
|
source = json.loads(ligne).get("apiKeySource")
|
|
|
|
|
if (source is not None and source != "none") or (source is None and '"type":"assistant"' in ligne):
|
2026-11-13 16:26:17 +01:00
|
|
|
p.kill()
|
2026-11-14 15:16:57 +01:00
|
|
|
sys.exit(f"{nom} arrêté : claude n'est pas sur l'abonnement (apiKeySource : {source}). /login.")
|
2026-11-13 16:26:17 +01:00
|
|
|
p.wait()
|
2026-11-14 15:16:57 +01:00
|
|
|
lignes = [json.loads(l) for l in chemin.read_text(encoding="utf-8").splitlines() if l.startswith("{")]
|
2026-11-13 16:24:49 +01:00
|
|
|
fin = next((l for l in reversed(lignes) if l.get("type") == "result"), None)
|
|
|
|
|
if fin is None:
|
2026-11-14 15:16:57 +01:00
|
|
|
print(f"claude n'a pas fini : voir {chemin.relative_to(RACINE)}")
|
2026-11-13 16:24:49 +01:00
|
|
|
return
|
|
|
|
|
print(fin.get("result", ""))
|
2026-11-13 16:26:17 +01:00
|
|
|
print(f"Sur l'abonnement : {fin.get('num_turns')} tours, {round(fin.get('duration_ms', 0) / 1000)} s "
|
|
|
|
|
f"(équivalent API, non facturé : {fin.get('total_cost_usd', 0):.2f} $)")
|
2026-11-13 16:24:49 +01:00
|
|
|
|
|
|
|
|
|
2026-11-14 15:16:57 +01:00
|
|
|
def scanner(dossier, jour):
|
|
|
|
|
"""L'étape 2 : l'agent scanner ; son flux dans scan.jsonl."""
|
|
|
|
|
rel = dossier.relative_to(RACINE)
|
|
|
|
|
demande = (f"Batch du {jour} (UTC) : {rel}/. Résumé des détecteurs : {rel}/detecteurs.md ; figures : "
|
|
|
|
|
f"{rel}/figures/<STATION>.png ; vérité à corriger : {rel}/verite/<STATION>.jsonl ; images de la caméra : "
|
|
|
|
|
f"data/<STATION>/images/. Écris {rel}/rapport.md.")
|
|
|
|
|
print("Scan en cours (claude -p, agent scanner)…", flush=True)
|
|
|
|
|
claude(dossier, "scan", [demande, "--agent", "scanner", "--allowedTools", "Read,Write,Edit,Bash(ls:*)"])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# la requête de /detectors:wf-improve (detectors/README.md), plusieurs stations sur le même jour ; tout ce qu'elle lit et
|
|
|
|
|
# écrit est donné ici, avec les règles git d'Optimizer
|
|
|
|
|
AMELIORER = (
|
|
|
|
|
"/detectors:wf-improve DETECTORS: detectors/. DATA: data. STATIONS: {stations}. FROM: {du}. TO: {au}. "
|
|
|
|
|
"LABELS: {b}/verite. REFERENCE: --labels labeling/auto --data data. FAMILIES: labeling/familles.md. "
|
|
|
|
|
"CONTEXT: {b}/rapport.md. OUT: {b}/improve/. Caller's context: Optimizer, a daily batch of every station. The labels "
|
|
|
|
|
"are the detectors' own events of the day, cut to the day (a label ending at midnight may go on), corrected by a "
|
|
|
|
|
"light scanner that saw each station from afar, on one figure; its report (CONTEXT) lists its corrections and the "
|
|
|
|
|
"doubts it left uncorrected: only its corrections differ from the detectors, and they are less sure than an "
|
|
|
|
|
"analyst's. detectors/ is a link to the detectors repository, shared with Diagnostic-app; read-only on data/ and "
|
|
|
|
|
"labeling/; commit only in detectors/, on its current branch; OUT is in the Optimizer repository: do not commit it.")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def ameliorer(dossier, d, stations):
|
2026-11-14 15:45:45 +01:00
|
|
|
"""L'étape 3 : /detectors:wf-improve, une séance sur les stations corrigées ; son flux dans improve.jsonl. Le plugin se
|
|
|
|
|
charge d'une copie (le skill et les agents) : claude refuse d'écrire dans les fichiers d'un plugin chargé, et la séance
|
|
|
|
|
doit écrire dans detectors/scripts/ (essai du 2026-11-05) ; ses commandes passent par DETECTORS, le vrai dépôt."""
|
2026-11-14 15:16:57 +01:00
|
|
|
rel = dossier.relative_to(RACINE)
|
|
|
|
|
requete = AMELIORER.format(stations=",".join(stations), du=iso(d)[:10], au=iso(d + timedelta(days=1))[:10], b=rel)
|
|
|
|
|
print(f"Amélioration en cours (claude -p, /detectors:wf-improve sur {', '.join(stations)})…", flush=True)
|
2026-11-14 15:45:45 +01:00
|
|
|
with tempfile.TemporaryDirectory(prefix="wf-improve-") as greffon:
|
|
|
|
|
for sous in (".claude-plugin", "skills", "agents"):
|
|
|
|
|
shutil.copytree(RACINE / "detectors" / sous, Path(greffon) / sous)
|
|
|
|
|
claude(dossier, "improve", [requete, "--plugin-dir", greffon, "--add-dir", str((RACINE / "detectors").resolve()),
|
|
|
|
|
"--allowedTools", "Read,Write,Edit,Bash,Agent"])
|
2026-11-14 15:16:57 +01:00
|
|
|
|
|
|
|
|
|
2026-11-13 16:24:49 +01:00
|
|
|
def lire(chemin):
|
|
|
|
|
return [json.loads(l) for l in chemin.read_text(encoding="utf-8").splitlines() if l.strip()] if chemin.exists() else []
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def controler(dossier, d):
|
2026-11-14 15:16:57 +01:00
|
|
|
"""La vérité après le scan : chaque ligne du JSON aux bonnes clés, une famille connue, des bornes dans le jour (le
|
|
|
|
|
début peut être la dernière mesure de la veille) ; puis
|
|
|
|
|
ce que le scanner a changé face aux détecteurs. -> (les stations corrigées, les erreurs)."""
|
2026-11-13 16:24:49 +01:00
|
|
|
b, problemes, changes = d + timedelta(days=1), [], {}
|
|
|
|
|
for p in sorted((dossier / "verite").glob("*.jsonl")):
|
|
|
|
|
apres = {}
|
|
|
|
|
for i, ligne in enumerate(p.read_text(encoding="utf-8").splitlines(), 1):
|
|
|
|
|
if not ligne.strip():
|
|
|
|
|
continue
|
|
|
|
|
try:
|
|
|
|
|
e = json.loads(ligne)
|
2026-11-14 15:22:25 +01:00
|
|
|
apres[e.get("id", f"ligne {i}")] = e # une ligne fautive n'est pas une étiquette retirée
|
2026-11-13 16:24:49 +01:00
|
|
|
assert not (manque := CLES - e.keys()), f"clés manquantes : {', '.join(sorted(manque))}"
|
|
|
|
|
assert e["categorie"] in FAMILLES, f"famille inconnue : {e['categorie']}"
|
2026-11-14 15:16:57 +01:00
|
|
|
assert d - timedelta(days=1) <= parse_time(e["debut"]) <= parse_time(e["fin"]) <= b \
|
|
|
|
|
and parse_time(e["fin"]) > d, "bornes hors du jour ou inversées"
|
2026-11-13 16:24:49 +01:00
|
|
|
except (json.JSONDecodeError, AssertionError, ValueError) as x:
|
|
|
|
|
problemes.append(f"{p.name}, ligne {i} : {x}")
|
|
|
|
|
avant = {e["id"]: e for e in lire(dossier / "detecteurs" / p.name)}
|
|
|
|
|
n = (len(apres.keys() - avant.keys()), len(avant.keys() - apres.keys()),
|
|
|
|
|
sum(apres[k] != avant[k] for k in apres.keys() & avant.keys()))
|
|
|
|
|
if any(n):
|
|
|
|
|
changes[p.stem] = n
|
|
|
|
|
for s, (a, r, m) in changes.items():
|
|
|
|
|
print(f"{s} : {a} ajoutées, {r} retirées, {m} modifiées")
|
|
|
|
|
print(f"Vérité : {len(changes) or 'aucune'} station(s) corrigée(s) ; "
|
|
|
|
|
+ ("contrôle sans erreur" if not problemes else "erreurs :\n " + "\n ".join(problemes)))
|
2026-11-14 15:16:57 +01:00
|
|
|
return sorted(changes), problemes
|
2026-11-13 16:24:49 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
|
p = argparse.ArgumentParser(usage=__doc__)
|
|
|
|
|
p.add_argument("--jour", default=str((datetime.now(timezone.utc) - timedelta(days=1)).date()))
|
|
|
|
|
p.add_argument("--stations", help="A,B : ces stations seulement (défaut : tous les dossiers de data/)")
|
|
|
|
|
p.add_argument("--sans-scan", action="store_true", help="l'étape des détecteurs seule")
|
|
|
|
|
a = p.parse_args()
|
|
|
|
|
d = datetime.strptime(a.jour, "%Y-%m-%d").replace(tzinfo=timezone.utc)
|
|
|
|
|
dossier = BATCHES / a.jour
|
|
|
|
|
if dossier.exists():
|
|
|
|
|
print(f"{dossier.relative_to(RACINE)}/ existe : l'étape des détecteurs est faite.")
|
|
|
|
|
else:
|
|
|
|
|
stations = a.stations.split(",") if a.stations else sorted(p.name for p in DONNEES.iterdir() if p.is_dir())
|
|
|
|
|
detecteurs(dossier, d, stations)
|
|
|
|
|
if a.sans_scan:
|
|
|
|
|
sys.exit()
|
|
|
|
|
if (dossier / "rapport.md").exists():
|
|
|
|
|
print("rapport.md existe : le scan est fait.")
|
|
|
|
|
else:
|
|
|
|
|
scanner(dossier, a.jour)
|
2026-11-14 15:16:57 +01:00
|
|
|
corrigees, erreurs = controler(dossier, d)
|
|
|
|
|
if (dossier / "improve" / "summary.md").exists():
|
|
|
|
|
print("improve/summary.md existe : l'amélioration est faite.")
|
|
|
|
|
elif erreurs or not corrigees:
|
|
|
|
|
print("Pas d'amélioration : " + ("la vérité a des erreurs." if erreurs else "le scanner n'a rien corrigé."))
|
|
|
|
|
else:
|
|
|
|
|
ameliorer(dossier, d, corrigees)
|