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.
|
|
|
|
|
|
|
|
|
|
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)
|
2026-11-13 16:26:17 +01:00
|
|
|
# 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")}
|
2026-11-13 16:24:49 +01:00
|
|
|
with open(dossier / "scan.jsonl", "w", encoding="utf-8") as flux:
|
2026-11-13 16:26:17 +01:00
|
|
|
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()
|
2026-11-13 16:24:49 +01:00
|
|
|
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", ""))
|
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
|
|
|
|
|
|
|
|
|
|
|
|
|
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)
|