Files
Support-Agent/API/tools/agent-tools/qualite.py
T
maximeandClaude Opus 5.5 8ba75b92fa API: support page with two Claude API clients, support and analyst (D-133)
Self-contained sub-project API/: a local support page where Marc pastes a
client's mail; a support agent and an analyst agent stay alive for the session
and produce a slide PDF that answers the client's question. Tools, detectors,
knowledge and Typst brand are copied (API/PROVENANCE.md). First real case:
Crissier (LENZSPITZE), workflow validated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 12:58:39 +01:00

419 lines
22 KiB
Python

"""Les six métriques de qualité d'image (peak, flux, sharpness, fwhm, dominance, snr) par capteur, face à sa référence calme.
Usage : python3 agent-tools/qualite.py <dossier> [--debut T] [--fin T] [--capteurs A,B] [--calme T1/T2,T3/T4]
[--commun] [--table METRIQUE] [--pas 15min] [--seuil 0.5]
python3 agent-tools/qualite.py <dossier> --etiquettes labeling/auto/X.jsonl [--calme ...] [--debut T] [--fin T]
[--numeros 3,7] [--seuil 0.5] [--marge 60] [--bords] | [--hors [--min 1] [--sauf "Thermal displacement"]]
.venv/bin/python agent-tools/qualite.py <dossier> --figure [--calme ...] [--debut T] [--fin T]
[--metriques flux,snr,dominance] [--etiquettes F] [--zone T1/T2 ...] [--sortie D]
python3 agent-tools/qualite.py --essai (contrôle du calcul du rapport)
Définitions : labeling/connaissances/metriques-de-qualite.md. Colonnes remplies sur les caméras récentes seulement ; sur un dossier où
elles sont vides, l'outil le dit et s'arrête.
Référence d'un capteur : la médiane de chaque métrique sur ses mesures des fenêtres --calme, à la même heure UTC du jour
(24 créneaux ; un créneau sans mesure calme prend la médiane de toutes les heures calmes). Sans --calme : tout le dossier.
Chaque mesure devient un rapport valeur / référence : 1 = comme la référence ; < 1 plus bas ; > 1 plus haut. Pour fwhm et
dominance, c'est la hausse qui dit une image dégradée (tache plus large, second pic plus fort). Mesures rejetées comprises
(la qualité de leur image reste mesurée).
Sans --etiquettes ni --figure :
1. le peak maximal du dossier, puis le résumé par capteur : mesures rejetées, « pk/max » (peak médian du capteur sur la
fenêtre divisé par ce maximum : une tache au plafond de l'image a un peak constant), et pour chaque métrique le rapport médian sur la fenêtre et l'extrême (min pour peak, flux, sharpness, snr ; max pour
fwhm, dominance) avec son instant ; puis les lignes « cibles » et « références » : la médiane des rapports médians ;
2. --commun : par pas de --pas, la médiane des rapports des cibles et celle des références, pour chaque métrique ;
3. --table M : par pas, le rapport de M de chaque capteur (« * » : une mesure du pas rejetée), « méd » (médiane sur les
capteurs) et le nombre de capteurs sous --seuil (au-dessus de 1/--seuil pour fwhm et dominance).
--etiquettes F (un JSON par ligne, debut, fin, categorie), sans --figure : par étiquette (numérotée dans l'ordre du
fichier ; --debut/--fin gardent celles qui y commencent), le rapport médian des cibles et des références sur l'heure
d'avant, la plage et l'heure d'après (--marge minutes) : « cib 0.95|0.40|0.97 » ; puis les capteurs « touchés » sur la
plage (flux ou snr sous --seuil, ou dominance au-dessus de 1/--seuil), avec leur pire rapport de flux, du plus bas au plus
haut (r = référence). --bords : par instant de la plage élargie de --marge, le nombre de capteurs touchés et la médiane
des cibles de flux, snr, dominance (« < » : dans la plage). --hors : à la place, les suites d'instants de --debut à --fin
qu'aucune étiquette ne couvre (hors familles --sauf), où au moins --min capteurs sont touchés (instants à moins de 15 min
groupés), avec les capteurs touchés et leur pire flux.
--figure (matplotlib) : PNG « qualite-commun » : un panneau par métrique, échelle logarithmique, médiane des cibles (noir),
des références (rouge) et bande du 10e au 90e centile des cibles ; PNG « qualite-<métrique> » par --metriques : un petit
graphique par capteur, références en rouge. --etiquettes grise chaque étiquette d'une couleur par famille ; --zone grise
des plages. Trait coupé sur un trou de plus de 30 min. Imprime le chemin de chaque PNG.
Rend des valeurs, pas de verdict. Lancé depuis la racine du dépôt.
"""
import argparse
import bisect
import json
import os
import statistics
import sys
from datetime import timedelta
import donnees
from resume import QUALITE as METRIQUES, duree
HAUT_MAUVAIS = ("fwhm", "dominance") # pour ces deux-là, c'est la hausse qui dit une image dégradée
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
COULEURS = {"Visibility": "tab:blue", "Obstruction": "tab:orange", "Thermal displacement": "tab:red",
"Displacement": "tab:purple", "Target issue": "tab:brown", "No data": "black"}
def fenetres(texte):
"""'T1/T2,T3/T4' -> [(début, fin)]."""
return [tuple(donnees.instant(b) for b in f.split("/")) for f in texte.split(",")] if texte else []
def dans(t, fen):
return any(a <= t <= b for a, b in fen)
def references(par, calme):
"""{capteur: {métrique: {heure: médiane, None: médiane toutes heures}}} sur les mesures calmes."""
ref = {}
for s, ms in par.items():
ref[s] = {}
for c in METRIQUES:
parh, tout = {}, []
for m in ms:
if m[c] is None or (calme and not dans(m["t"], calme)):
continue
parh.setdefault(m["t"].hour, []).append(m[c])
tout.append(m[c])
r = {h: statistics.median(v) for h, v in parh.items()}
r[None] = statistics.median(tout) if tout else None
ref[s][c] = r
return ref
def rapport(ref, s, c, m):
r = ref[s][c].get(m["t"].hour, ref[s][c][None])
return m[c] / r if m[c] is not None and r else None
def touche(r, c, seuil):
return r is not None and ((c in ("flux", "snr") and r < seuil) or (c == "dominance" and r > 1 / seuil))
def med(v):
return f"{statistics.median(v):.2f}" if v else "-"
def resume(par, ref, noms, refs, pmax):
print(f"peak maximal du dossier : {pmax if pmax is None else f'{pmax:g}'} ; pk/max : peak médian du capteur sur la "
"fenêtre, divisé par ce maximum")
print("Résumé : rapport médian à la référence calme, puis l'extrême et son instant (UTC)")
print(f"{'capteur':>12} {'rej':>4} {'pk/max':>6} " + " ".join(f"{c:>26}" for c in METRIQUES))
meds = {c: {"cibles": [], "références": []} for c in METRIQUES}
for s in noms:
ms = par[s]
if not ms:
continue
cases = []
for c in METRIQUES:
rs = [(rapport(ref, s, c, m), m["t"]) for m in ms]
rs = [x for x in rs if x[0] is not None]
if not rs:
cases.append(f"{'vide':>26}")
continue
md = statistics.median(r for r, _ in rs)
ext = (max if c in HAUT_MAUVAIS else min)(rs, key=lambda x: x[0])
meds[c]["références" if s in refs else "cibles"].append(md)
cases.append(f"{md:6.2f} ({ext[0]:6.2f} {ext[1]:%d/%m %H:%M})")
rej = sum(1 for m in ms if donnees.rejetee(m))
pk = [m["peak"] for m in ms if m["peak"] is not None]
pk = f"{statistics.median(pk) / pmax:6.2f}" if pk and pmax else f"{'-':>6}"
print(f"{s + ('r' if s in refs else ''):>12} {rej:>4} {pk} " + " ".join(cases))
for g in ("cibles", "références"):
print(f"{g:>24} " + " ".join(f"{statistics.median(meds[c][g]):26.2f}" if meds[c][g] else f"{'-':>26}"
for c in METRIQUES))
def par_pas(par, noms, pas):
pas = duree(pas)
debut = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0)
return lambda t: debut + (t - debut) // pas * pas
def table(par, ref, noms, c, pas, seuil):
cle, cases = par_pas(par, noms, pas), {}
for s in noms:
for m in par[s]:
r = rapport(ref, s, c, m)
if r is not None:
cases.setdefault(cle(m["t"]), {}).setdefault(s, []).append((r, donnees.rejetee(m)))
haut = c in HAUT_MAUVAIS
print(f"\nTable de {c} / référence, pas de {pas} ('*' : une mesure du pas rejetée)")
w = max(7, *map(len, noms))
entete = f"{'instant':16} " + " ".join(f"{s:>{w}}" for s in noms) + f" {'méd':>6} {'n' + ('>' if haut else '<') + str(seuil):>6}"
for i, k in enumerate(sorted(cases)):
if i % 24 == 0:
print(entete)
ligne, vals = [], []
for s in noms:
v = cases[k].get(s)
if not v:
ligne.append(f"{'':>{w}}")
continue
r = statistics.median(x for x, _ in v)
vals.append(r)
ligne.append(f"{r:{w - 1}.2f}" + ("*" if any(j for _, j in v) else " "))
n = sum(1 for r in vals if (r > 1 / seuil if haut else r < seuil))
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(ligne) + f" {statistics.median(vals):6.2f} {n:>6}")
def commun(par, ref, noms, refs, pas):
"""Par pas : médiane des rapports des cibles, puis des références, pour chaque métrique."""
cle, cases = par_pas(par, noms, pas), {}
for s in noms:
for m in par[s]:
d = cases.setdefault(cle(m["t"]), {c: ([], []) for c in METRIQUES})
for c in METRIQUES:
r = rapport(ref, s, c, m)
if r is not None:
d[c][s in refs].append(r)
print(f"\nMédianes des rapports par pas de {pas} : cibles / références")
entete = f"{'instant':16} " + " ".join(f"{c:>13}" for c in METRIQUES)
for i, k in enumerate(sorted(cases)):
if i % 24 == 0:
print(entete)
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(
f"{statistics.median(cases[k][c][0]) if cases[k][c][0] else float('nan'):6.2f}/"
f"{statistics.median(cases[k][c][1]) if cases[k][c][1] else float('nan'):<6.2f}" for c in METRIQUES))
def lire_etiquettes(chemin):
return [json.loads(ligne) for ligne in open(chemin) if ligne.strip()]
def etiquettes(a, tout, ref, refs, noms, deb, fin):
marge = timedelta(minutes=a.marge)
temps = {s: [m["t"] for m in tout[s]] for s in noms}
garder = {int(n) for n in a.numeros.split(",")} if a.numeros else None
print(f"Référence calme : {a.calme or 'tout le dossier'} ; rapports médians avant|plage|après ({a.marge} min)")
for n, e in enumerate(lire_etiquettes(a.etiquettes), 1):
t0, t1 = donnees.instant(e["debut"]), donnees.instant(e["fin"])
if (garder and n not in garder) or (deb and t0 < deb) or (fin and t0 > fin):
continue
print(f"\n{n}. {e['debut']} → {e['fin']}, {e['categorie']}")
win = {s: tout[s][bisect.bisect_left(temps[s], t0 - marge):bisect.bisect_right(temps[s], t1 + marge)] for s in noms}
parties = [(t0 - marge, t0 - timedelta(seconds=1)), (t0, t1), (t1 + timedelta(seconds=1), t1 + marge)]
for c in METRIQUES:
cases = []
for g in (False, True):
vals = []
for a0, a1 in parties:
v = [rapport(ref, s, c, m) for s in win if (s in refs) == g for m in win[s] if a0 <= m["t"] <= a1]
vals.append(med([x for x in v if x is not None]))
cases.append(("ref " if g else "cib ") + "|".join(vals))
print(f" {c:>9} " + " ".join(cases))
pires = []
for s in noms:
ms = [m for m in win[s] if t0 <= m["t"] <= t1]
if any(touche(rapport(ref, s, c, m), c, a.seuil) for m in ms for c in ("flux", "snr", "dominance")):
fl = [x for x in (rapport(ref, s, "flux", m) for m in ms) if x is not None]
pires.append((min(fl) if fl else 1, s + ("r" if s in refs else "")))
pires.sort()
print(f" touchés ({len(pires)}) : " + ", ".join(f"{s} {f:.2f}" for f, s in pires) if pires else " touchés : aucun")
if a.bords:
inst = {}
for s in win:
for m in win[s]:
d = inst.setdefault(m["t"], {"n": 0, "flux": [], "snr": [], "dominance": []})
rs = {c: rapport(ref, s, c, m) for c in ("flux", "snr", "dominance")}
d["n"] += any(touche(rs[c], c, a.seuil) for c in rs)
if s not in refs:
for c in rs:
if rs[c] is not None:
d[c].append(rs[c])
print(" instant n flux snr dom")
for t in sorted(inst):
d = inst[t]
print(f" {t:%Y-%m-%d %H:%M} {d['n']:>3} {med(d['flux']):>5} {med(d['snr']):>5} {med(d['dominance']):>5}"
+ (" <" if t0 <= t <= t1 else ""))
def hors(a, tout, ref, refs, noms, deb, fin):
sauf = set(a.sauf.split(",")) if a.sauf else set()
couvert = [(donnees.instant(e["debut"]), donnees.instant(e["fin"])) for e in lire_etiquettes(a.etiquettes)
if e["categorie"] not in sauf]
inst = {}
for s in noms:
for m in donnees.filtrer(tout[s], deb, fin):
if dans(m["t"], couvert):
continue
if any(touche(rapport(ref, s, c, m), c, a.seuil) for c in ("flux", "snr", "dominance")):
inst.setdefault(m["t"], {})[s + ("r" if s in refs else "")] = rapport(ref, s, "flux", m) or 0
suites = []
for t in sorted(t for t in inst if len(inst[t]) >= a.min):
if suites and t - suites[-1][-1] <= timedelta(minutes=15):
suites[-1].append(t)
else:
suites.append([t])
print(f"Hors des étiquettes (sauf {a.sauf}) : instants où au moins {a.min} capteurs sont touchés ; {len(suites)} suites")
for su in suites:
pire = {}
for t in su:
for s, f in inst[t].items():
pire[s] = min(pire.get(s, 9), f)
print(f"{su[0]:%Y-%m-%d %H:%M} → {su[-1]:%H:%M} ({len(su)}) : "
+ ", ".join(f"{s} {f:.2f}" for s, f in sorted(pire.items(), key=lambda x: x[1])))
def morceaux(pts, trou=timedelta(minutes=30)):
"""[(t, ...)] -> listes coupées là où deux instants sont à plus de `trou` : un trait ne traverse pas un trou de mesures."""
out = []
for i, x in enumerate(pts):
if not out or x[0] - pts[i - 1][0] > trou:
out.append([])
out[-1].append(x)
return out
def figure(a, par, ref, noms, refs, deb, fin):
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
plages = [(x, y, "grey") for x, y in fenetres(",".join(a.zone or []))]
if a.etiquettes:
for e in lire_etiquettes(a.etiquettes):
x, y = donnees.instant(e["debut"]), donnees.instant(e["fin"])
if (deb is None or y >= deb) and (fin is None or x <= fin):
plages.append((x, y, COULEURS.get(e["categorie"], "grey")))
station = os.path.basename(os.path.normpath(a.dossier))
t0 = min(m["t"] for s in noms for m in par[s])
t1 = max(m["t"] for s in noms for m in par[s])
suffixe = f"{t0:%Y%m%dT%H%MZ}_{t1:%Y%m%dT%H%MZ}"
os.makedirs(a.sortie, exist_ok=True)
def axe(ax):
for x, y, couleur in plages:
ax.axvspan(x, y, color=couleur, alpha=0.12, lw=0)
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%M"))
ax.set_yscale("log")
ax.axhline(1, ls=":", c="k", lw=0.8)
ax.set_xlim(t0, t1)
fig, axes = plt.subplots(len(METRIQUES), 1, figsize=(16, 2.4 * len(METRIQUES)), sharex=True)
for ax, c in zip(axes, METRIQUES):
inst = {}
for s in noms:
for m in par[s]:
r = rapport(ref, s, c, m)
if r is not None and r > 0:
inst.setdefault(m["t"], ([], []))[s in refs].append(r)
ts = sorted(inst)
cib = [(t, sorted(inst[t][0])) for t in ts if inst[t][0]]
rfs = [(t, statistics.median(inst[t][1])) for t in ts if inst[t][1]]
for i, mc in enumerate(morceaux(cib)):
ax.fill_between([t for t, _ in mc], [v[len(v) // 10] for _, v in mc], [v[(len(v) * 9) // 10] for _, v in mc],
color="0.8", lw=0, step="mid")
ax.plot([t for t, _ in mc], [statistics.median(v) for _, v in mc], c="k", lw=0.7,
label="cibles (médiane, bande 10-90 %)" if i == 0 else None)
for i, mc in enumerate(morceaux(rfs)):
ax.plot([t for t, _ in mc], [v for _, v in mc], c="tab:red", lw=0.7, label="références (médiane)" if i == 0 else None)
axe(ax)
ax.set_ylabel(c)
axes[0].legend(loc="upper right", fontsize=8)
axes[0].set_title(f"{station} : métriques de qualité / référence calme ({a.calme or 'tout le dossier'}), même heure UTC")
chemin = os.path.join(a.sortie, f"{station}_qualite-commun_{suffixe}.png")
fig.tight_layout()
fig.savefig(chemin, dpi=90)
plt.close(fig)
print(chemin)
for c in a.metriques.split(","):
col = 6
lig = (len(noms) + col - 1) // col
fig, axes = plt.subplots(lig, col, figsize=(3.2 * col, 1.9 * lig), sharex=True, squeeze=False)
for ax, s in zip(axes.flat, noms):
pts = [(m["t"], rapport(ref, s, c, m)) for m in par[s]]
pts = [(t, r) for t, r in pts if r is not None and r > 0]
for mc in morceaux(pts):
ax.plot([t for t, _ in mc], [r for _, r in mc], lw=0.5, c="tab:red" if s in refs else "k")
axe(ax)
ax.set_title(s, fontsize=8, color="tab:red" if s in refs else "k")
ax.tick_params(labelsize=6)
for ax in list(axes.flat)[len(noms):]:
ax.axis("off")
fig.suptitle(f"{station} : {c} / référence calme, par capteur (références en rouge)")
chemin = os.path.join(a.sortie, f"{station}_qualite-{c}_{suffixe}.png")
fig.tight_layout()
fig.savefig(chemin, dpi=80)
plt.close(fig)
print(chemin)
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("dossier")
p.add_argument("--debut", type=donnees.instant)
p.add_argument("--fin", type=donnees.instant)
p.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
p.add_argument("--calme", help="fenêtres de la référence, T1/T2,T3/T4 (défaut : tout le dossier)")
p.add_argument("--commun", action="store_true", help="médianes des cibles et des références par pas")
p.add_argument("--table", choices=METRIQUES, help="rapport d'une métrique par pas et par capteur")
p.add_argument("--pas", default="15min", type=lambda x: duree(x) and x, help="15min, 1h, 1d")
p.add_argument("--seuil", type=float, default=0.5, help="« touché » : flux ou snr sous seuil, dominance au-dessus de 1/seuil")
p.add_argument("--etiquettes", help="fichier d'étiquettes (JSON par ligne)")
p.add_argument("--numeros", help="numéros d'étiquettes à lire, 3,7")
p.add_argument("--marge", type=int, default=60, help="minutes avant et après chaque étiquette")
p.add_argument("--bords", action="store_true")
p.add_argument("--hors", action="store_true", help="instants touchés qu'aucune étiquette ne couvre")
p.add_argument("--min", type=int, default=1)
p.add_argument("--sauf", default="Thermal displacement", help="familles ignorées par --hors, A,B")
p.add_argument("--figure", action="store_true", help="PNG (matplotlib : .venv/bin/python)")
p.add_argument("--metriques", default="flux,snr,dominance", help="PNG par capteur de --figure")
p.add_argument("--zone", action="append", help="plage à griser sur les PNG, T1/T2 (répétable)")
p.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
a = p.parse_args()
if a.hors and not a.etiquettes:
p.error("--hors demande --etiquettes")
inconnues = [c for c in a.metriques.split(",") if c not in METRIQUES]
if inconnues:
p.error(f"métriques inconnues : {', '.join(inconnues)} ; connues : {', '.join(METRIQUES)}")
tout = donnees.charger(a.dossier)
if not tout:
sys.exit(f"Aucun export « advanced » dans {a.dossier} (voir inventaire.py).")
if not any(m[c] is not None for ms in tout.values() for m in ms for c in METRIQUES):
sys.exit(f"Aucune métrique de qualité dans {a.dossier} : peak à snr vides (caméra ancienne ; "
"labeling/connaissances/metriques-de-qualite.md).")
noms = a.capteurs.split(",") if a.capteurs else sorted(tout, key=lambda s: (not donnees.est_reference(tout[s]), s))
absents = [s for s in noms if s not in tout]
if absents:
sys.exit(f"Capteurs absents : {', '.join(absents)}. Présents : {', '.join(sorted(tout))}.")
ref = references(tout, fenetres(a.calme))
refs = {s for s in tout if donnees.est_reference(tout[s])}
par = {s: donnees.filtrer(tout[s], a.debut, a.fin) for s in noms}
if not any(par.values()):
sys.exit("Aucune mesure dans la fenêtre demandée.")
if a.figure:
return figure(a, par, ref, noms, refs, a.debut, a.fin)
if a.etiquettes:
return (hors if a.hors else etiquettes)(a, tout, ref, refs, noms, a.debut, a.fin)
pmax = max((m["peak"] for ms in tout.values() for m in ms if m["peak"] is not None), default=None)
print(f"Référence calme : {a.calme or 'tout le dossier'}, par heure UTC du jour (r = référence)")
resume(par, ref, noms, refs, pmax)
if a.commun:
commun(par, ref, noms, refs, a.pas)
if a.table:
table(par, ref, noms, a.table, a.pas, a.seuil)
def essai():
"""Contrôle du rapport à la référence : même heure, repli sur toutes les heures, fenêtre calme respectée."""
from datetime import datetime, timezone
t = lambda j, h: datetime(2026, 10, j, h, tzinfo=timezone.utc) # noqa: E731
vide = dict.fromkeys(METRIQUES)
par = {"A": [dict(vide, t=t(1, 3), flux=10.0), dict(vide, t=t(2, 3), flux=30.0), dict(vide, t=t(2, 5), flux=100.0),
dict(vide, t=t(9, 3), flux=1000.0)]}
ref = references(par, [(t(1, 0), t(3, 0))])
assert ref["A"]["flux"][3] == 20.0 and ref["A"]["flux"][None] == 30.0, ref
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 3), flux=10.0)) == 0.5
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 7), flux=60.0)) == 2.0 # heure sans calme : toutes les heures
assert rapport(ref, "A", "snr", dict(vide, t=t(9, 3), snr=5.0)) is None
assert touche(0.4, "flux", 0.5) and touche(2.5, "dominance", 0.5) and not touche(2.5, "flux", 0.5)
print("essai : ok")
if __name__ == "__main__":
essai() if sys.argv[1:] == ["--essai"] else main()