Files
aimsight-optimizer/archive/batch.py
T

383 lines
24 KiB
Python
Raw Normal View History

"""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.
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,
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
import statistics
import subprocess
import sys
import tempfile
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) <= 12 else f"{len(s)} capteurs" # 12 : un groupe se reconnaît
def etiquettes(station, mesures, d):
"""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)]
# 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), au plus
# tôt la veille à 00:00 (un No data de plusieurs jours)
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"])
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)),
"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]
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):
"""[(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, 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
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: # 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: 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)
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]]
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, 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)
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(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
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"] 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)
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\nacceptés)", 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)
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):
"""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} ; {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)", "",
"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 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 ; 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):
"""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."""
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)
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"])
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 (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 = {}
for i, ligne in enumerate(p.read_text(encoding="utf-8").splitlines(), 1):
if not ligne.strip():
continue
try:
e = json.loads(ligne)
apres[e.get("id", f"ligne {i}")] = e # une ligne fautive n'est pas une étiquette retirée
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 - 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"
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)))
return sorted(changes), 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)
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)