L'amélioration branchée (étape 3) ; figure, bornes et scanner corrigés après l'essai du 2026-11-05

- étape 3 : /detectors:wf-improve, une séance sur les stations que le scanner a corrigées (DATA, STATIONS, LABELS = verite/), sorties dans batches/<jour>/improve/ ;
- claude -p commun aux deux agents, isolé des réglages du poste (--setting-sources project,local, --strict-mcp-config : plus de hooks ni de plugins de l'utilisateur), toujours l'abonnement seulement, arrêté s'il répond sans avoir dit sa source ; flux écrit ligne à ligne ;
- figure : une mesure rejetée interrompt la courbe (min(lim, nan) la dessinait en pic à l'écrêtage), une vraie mesure l'emporte sur un rejet dans son pas, références rejetées en noir ;
- étiquettes des détecteurs de la mesure d'avant à celle d'après (sauf No data), commencées la veille à la dernière mesure d'avant minuit : à vérité intacte, le score de plage est à 100 % ;
- detecteurs.md : références nommées, cadence par rafales, fin à 24:00 ;
- scanner : la figure, les bornes d'une mesure à l'autre, les ratés sous une étiquette longue, trois signatures trompeuses, une étiquette par passage, une image par doute de famille.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-14 15:16:57 +01:00
1 parent ca65855e27
commit dab71a9037
3 files changed
+124 -52

No files matched your search

+8 -8
View File
@@ -9,15 +9,15 @@ Tu es le scanner d'Optimizer, un critique léger des détecteurs. Sur un jour UT
## Ce que tu as
- `<batch>/detecteurs.md` : par station, ses capteurs et les étiquettes des détecteurs (id court `D1`…, heures, famille : variété, capteurs ; « grisé » : non montré au client, mais détecté comme les autres).
- `<batch>/detecteurs.md` : par station, ses capteurs (les références nommées), sa cadence (« par rafales » : quelques mesures à une minute d'intervalle, puis une pause) et les étiquettes des détecteurs (id court `D1`…, heures, famille : variété, capteurs ; « grisé » : non montré au client, mais détecté comme les autres). Les bornes d'une étiquette sont la mesure d'avant l'anomalie et celle d'après : une anomalie d'une seule mesure, à 4 h de cadence, couvre 8 h ; une étiquette commencée la veille part de la dernière mesure d'avant minuit.
- `<batch>/figures/<STATION>.png`, sur les 24 h, de haut en bas :
1. les étiquettes, une ligne par famille, avec leur id court ;
2. et 3. `corr_x` et `corr_y` des cibles, chacune en écart à sa médiane du jour, en bruits propres ; entre les pointillés ±5, une courbe est calme ; écrêtées en haut et en bas ; le nom des cibles qui sortent le plus du calme ; les références ne sont pas tracées ;
4. le nombre de capteurs rejetés (rouge) et manquants (gris) ; hachuré : aucune mesure d'aucun capteur ;
2. et 3. `corr_x` et `corr_y` des cibles, chacune en écart à sa médiane du jour, en bruits propres ; entre les pointillés ±5, une courbe est calme ; écrêtées en haut et en bas ; le nom des cibles qui sortent le plus du calme ; les références ne sont pas tracées ; une mesure rejetée non plus : la courbe s'interrompt ;
4. le nombre de capteurs rejetés, les références en noir, les cibles en rouge, et manquants (gris) ; hachuré : aucune mesure d'aucun capteur ;
5. la température du boîtier (rouge) et l'`error_value` rapportée à son seuil, médiane des capteurs (bleu ; 1 : le seuil).
- `<batch>/verite/<STATION>.jsonl` : les étiquettes des détecteurs, une par ligne, `{"id", "debut", "fin", "categorie", "description"}`, que tu corriges.
- `labeling/familles.md` : les familles et leurs frontières. **Lis-le en entier d'abord.**
- `data/<STATION>/images/` : les images de la caméra, `AAAAMMJJTHHMMZ_<n>.jpg`, à peu près une par heure ; les trouver : `ls data/<STATION>/images/20261112T14*`. **Cinq images au plus pour tout le batch**, seulement quand la famille ne se décide pas autrement.
- `data/<STATION>/images/` : les images de la caméra, `AAAAMMJJTHHMMZ_<n>.jpg`, à peu près une par heure ; les trouver : `ls data/<STATION>/images/20261112T14*`. **Cinq images au plus pour tout le batch** : pour un doute de famille qu'une image peut trancher (un passage, un véhicule garé, une toile d'araignée devant une référence), regarde celle de l'heure avant d'y renoncer.
Tu ne lis jamais les CSV de `data/`, ni le code des détecteurs.
@@ -27,10 +27,10 @@ Ce qui rend `corr_x` ou `corr_y` non plates (un pic, un saut, une dérive, du br
## Les irrégularités
- **raté** : les courbes sortent du calme, ou manquent, et aucune étiquette ne couvre ce moment.
- **raté** : les courbes sortent du calme, ou manquent, et aucune étiquette ne l'explique. Ce qui tombe sous une étiquette longue d'une autre famille (Thermal displacement, une Visibility de plusieurs heures) et s'en distingue (un rejet bref, un saut qui revient) est un raté.
- **trop** : une étiquette sur des courbes calmes, mesures présentes et acceptées (hors Thermal displacement) ; un `No data` alors que les mesures sont là ; deux étiquettes de la même famille sur les mêmes heures (l'une est de trop).
- **bornes** : une étiquette qui commence ou finit à plus d'une heure de ce que montrent les courbes. Moins d'une heure : pas une irrégularité, la figure n'est pas assez fine.
- **famille** : la forme dit une autre famille, selon `labeling/familles.md` (une ou quelques cibles qui s'écartent, le reste calme ; toute la scène, `error_value` qui monte, beaucoup de rejets ; une onde qui suit la température ; un saut qui dure ; aucune mesure d'aucun capteur).
- **bornes** : une étiquette qui commence ou finit à plus d'une heure, et à plus d'une mesure, de ce que montrent les courbes. Moins : pas une irrégularité, la figure n'est pas assez fine.
- **famille** : la forme dit une autre famille, selon `labeling/familles.md` (une ou quelques cibles qui s'écartent, le reste calme ; toute la scène, `error_value` qui monte, beaucoup de rejets ; une onde qui suit la température ; un saut qui dure ; aucune mesure d'aucun capteur). Trois signatures trompeuses : une référence rejetée (noir) quand toutes les cibles sautent ensemble puis reviennent, c'est un passage devant la référence, Obstruction ; un même groupe de cibles rejeté par moments, le reste mesuré, même la moitié de la scène, Obstruction ; une agitation de jour sans que l'`error_value` monte, thermique, pas Visibility.
Ne sont pas des irrégularités : un trou aux mêmes heures sur plusieurs stations (une cause commune, `No data` reste juste) ; un trou à la toute fin du jour (les données ne sont peut-être pas encore pompées).
@@ -40,7 +40,7 @@ Pour chaque irrégularité sûre, une correction dans `<batch>/verite/<STATION>.
- **trop** : retire la ligne ;
- **bornes** : change `debut` ou `fin` ;
- **famille** : change `categorie` (une clé de `labeling/familles.md`) ;
- **raté** : ajoute une ligne, `"id": "<STATION>-<jour>-S<n>"`, ses bornes de la dernière mesure calme avant l'anomalie à la première mesure calme après, `"AAAA-MM-JJTHH:MMZ"`, dans le jour ; sa description en français : ce que montre la figure, les cibles touchées, `(scanner)`.
- **raté** : ajoute une ligne, `"id": "<STATION>-<jour>-S<n>"`, ses bornes de la dernière mesure calme avant l'anomalie à la première mesure calme après, `"AAAA-MM-JJTHH:MMZ"`, dans le jour ; sa description en français : ce que montre la figure, les cibles touchées, `(scanner)`. Un événement qui se répète (des passages) : une ligne par fois, jamais une seule ligne pour plusieurs.
Une ligne changée garde sa description et y ajoute ` Scanner : <la correction, en une phrase>.` Une ligne par étiquette, du JSON valide.
+1
View File
@@ -6,3 +6,4 @@ __pycache__/
batches/*.tmp/
batches/*/figures/
batches/*/scan.jsonl
batches/*/improve.jsonl
+115 -44
View File
@@ -5,13 +5,17 @@
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.
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/.
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.
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.
Toute heure est en UTC.
"""
import argparse
import bisect
import json
import os
import shutil
@@ -51,11 +55,23 @@ def capteurs(v):
def etiquettes(station, mesures, d):
"""Les événements des détecteurs qui touchent le jour, en étiquettes coupées au jour."""
"""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 »."""
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)),
# 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 ;
# commencé la veille : la dernière mesure d'avant minuit (coupée à 00:00, la mesure de minuit serait une borne)
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"])
return [{"id": f"{station}-{jour}-D{i}", "debut": max(v["start"], avant(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)]
@@ -64,7 +80,10 @@ def etiquettes(station, mesures, d):
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}"
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}"
def coupe(points, pas):
@@ -89,7 +108,7 @@ def figure(station, mesures, temperature, labels, d, chemin):
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)."""
Rend (cibles, références, la cadence en mots, 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
@@ -122,14 +141,14 @@ def figure(station, mesures, temperature, labels, d, chemin):
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
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
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
bride = lambda x: x if x != x else max(-lim, min(lim, x)) # noqa: E731 — NaN reste NaN : la courbe s'interrompt
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)
@@ -147,10 +166,13 @@ def figure(station, mesures, temperature, labels, d, chemin):
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]
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]
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, 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")
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)
@@ -158,7 +180,7 @@ def figure(station, mesures, temperature, labels, d, chemin):
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].set_ylabel("capteurs\nrejetés, manquants\n(noir : références ;\nhachuré : 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
@@ -185,7 +207,16 @@ def figure(station, mesures, temperature, labels, d, chemin):
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)
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)
def detecteurs(dossier, d, stations):
@@ -206,8 +237,8 @@ def detecteurs(dossier, d, stations):
(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),
resume += [f"## {station}", "", f"figures/{station}.png ; {nc} cibles, {nr} ; {pas}, {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)", "",
@@ -218,35 +249,66 @@ def detecteurs(dossier, d, stations):
tmp.rename(dossier)
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."""
env = {k: v for k, v in os.environ.items() if k not in ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN")}
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)
for ligne in p.stdout:
flux.write(ligne)
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):
p.kill()
sys.exit(f"{nom} arrêté : claude n'est pas sur l'abonnement (apiKeySource : {source}). /login.")
p.wait()
lignes = [json.loads(l) for l in chemin.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(f"claude n'a pas fini : voir {chemin.relative_to(RACINE)}")
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 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."""
"""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)
# 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} $)")
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):
"""L'étape 3 : /detectors:wf-improve, une séance sur les stations corrigées ; son flux dans improve.jsonl."""
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)
claude(dossier, "improve", [requete, "--plugin-dir", "detectors", "--add-dir", str((RACINE / "detectors").resolve()),
"--allowedTools", "Read,Write,Edit,Bash,Agent"])
def lire(chemin):
@@ -254,8 +316,9 @@ def lire(chemin):
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."""
"""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)."""
b, problemes, changes = d + timedelta(days=1), [], {}
for p in sorted((dossier / "verite").glob("*.jsonl")):
apres = {}
@@ -266,7 +329,8 @@ def controler(dossier, d):
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"
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"
apres[e["id"]] = e
except (json.JSONDecodeError, AssertionError, ValueError) as x:
problemes.append(f"{p.name}, ligne {i} : {x}")
@@ -279,6 +343,7 @@ def controler(dossier, d):
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)))
return sorted(changes), problemes
if __name__ == "__main__":
@@ -300,4 +365,10 @@ if __name__ == "__main__":
print("rapport.md existe : le scan est fait.")
else:
scanner(dossier, a.jour)
controler(dossier, d)
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)