Files
aimsight-optimizer/batch.py
T
maximeandClaude Opus 5.5 443f3588f6 Le scan sur l'abonnement Claude seulement, jamais sur une clé d'API
batch.py lance claude -p sans ANTHROPIC_API_KEY ni ANTHROPIC_AUTH_TOKEN et
l'arrête si son message d'ouverture dit une autre source que l'abonnement ;
le montant en $ est affiché comme équivalent API, non facturé. Le résultat
du scan est lu quel que soit l'ordre des clés du flux.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 16:26:17 +01:00

304 lines
17 KiB
Python

"""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.
Usage : python3 batch.py [--jour AAAA-MM-JJ] [--stations A,B] [--sans-scan]
Jour par défaut : hier (UTC). Une étape faite ne se refait pas (le dossier du batch existe, rapport.md existe) : relancer
après --sans-scan fait le scan seul ; supprimer batches/<jour>/ pour tout refaire.
Toute heure est en UTC.
"""
import argparse
import json
import os
import shutil
import statistics
import subprocess
import sys
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"]
return "tous les capteurs" if not s else ", ".join(s) if len(s) <= 6 else f"{len(s)} capteurs"
def etiquettes(station, mesures, d):
"""Les événements des détecteurs qui touchent le jour, en étiquettes coupées au jour."""
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)]
return [{"id": f"{station}-{jour}-D{i}", "debut": max(v["start"], iso(d)), "fin": min(v["end"], iso(b)),
"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]
return f"- {e['id'].rsplit('-', 1)[1]} {e['debut'][11:16]} → {e['fin'][11:16]} {e['categorie']} : {quoi}"
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).
Rend (cibles, références, minutes entre deux instants de mesure, instants)."""
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), {}
for m in ms:
x = float("nan") if m[col] is None else (m[col] - med) / bruit
if not abs(pire.get(case(m["t"]), float("nan"))) >= abs(x): # le plus grand ; NaN s'il n'y a rien
pire[case(m["t"])] = x
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
bride = lambda x: max(-lim, min(lim, x)) # noqa: E731
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]]
rej = [len({s for s in actifs for m in par[s] if case(m["t"]) == k and rejected(m)}) for k in cases]
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]
ax[3].bar(x, rej, width=PAS, color="tab:red", label="rejetées")
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))
ax[3].set_ylabel("capteurs\nrejetés, manquants\n(hachuré : rien)", fontsize=8)
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]:
if m["error_value"] is not None and m["error_threshold"]:
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)
a2.set_ylabel("error_value / seuil\n(médiane des capteurs)", fontsize=8, color="tab:blue")
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)
return len(cibles), len(jour) - len(cibles), round(statistics.median(natif)) if natif else 0, len(instants)
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")
resume += [f"## {station}", "", f"figures/{station}.png ; {nc} cibles, {nr} références ; une mesure toutes les "
f"{pas} min, {n} instants mesurés.", "", *map(courte, labels),
*([] 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)
def scanner(dossier, jour):
"""L'étape 2 : l'agent scanner par claude -p ; son flux dans scan.jsonl ; imprime sa réponse et son coût."""
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)
# l'abonnement Claude seulement, jamais une clé d'API : sans elles dans l'environnement, claude prend la connexion
# claude.ai ; et si son message d'ouverture dit une autre source (apiKeyHelper…), il est arrêté avant tout appel
env = {k: v for k, v in os.environ.items() if k not in ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN")}
with open(dossier / "scan.jsonl", "w", encoding="utf-8") as flux:
p = subprocess.Popen(["claude", "-p", demande, "--agent", "scanner", "--permission-mode", "acceptEdits",
"--allowedTools", "Read,Write,Edit,Bash(ls:*)", "--output-format", "stream-json",
"--verbose"], cwd=RACINE, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
for ligne in p.stdout:
flux.write(ligne)
if ligne.startswith('{"type":"system","subtype":"init"') and (s := json.loads(ligne).get("apiKeySource")) != "none":
p.kill()
sys.exit(f"Scan arrêté : claude n'est pas sur l'abonnement (apiKeySource : {s}). Se connecter par /login.")
p.wait()
lignes = [json.loads(l) for l in (dossier / "scan.jsonl").read_text(encoding="utf-8").splitlines()
if l.startswith("{")]
fin = next((l for l in reversed(lignes) if l.get("type") == "result"), None)
if fin is None:
print("Le scan n'a pas fini : voir scan.jsonl")
return
print(fin.get("result", ""))
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} $)")
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):
"""La vérité après le scan : chaque ligne du JSON aux bonnes clés, une famille connue, des bornes dans le jour ; puis
ce que le scanner a changé face aux détecteurs."""
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)
assert not (manque := CLES - e.keys()), f"clés manquantes : {', '.join(sorted(manque))}"
assert e["categorie"] in FAMILLES, f"famille inconnue : {e['categorie']}"
assert d <= parse_time(e["debut"]) <= parse_time(e["fin"]) <= b, "bornes hors du jour ou inversées"
apres[e["id"]] = e
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)))
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)
controler(dossier, d)