Copie des agents de Support-Agent/API (sortie mail)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
cbaab49d3f
commit
5e3faa47b4
49 files changed
+6662
No files matched your search
@@ -0,0 +1,156 @@
|
||||
"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic.
|
||||
|
||||
Usage : python3 agent-tools/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y]
|
||||
[--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N]
|
||||
[--capteurs A,B] [--debut ...] [--fin ...]
|
||||
|
||||
Pour chaque colonne, chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane des
|
||||
valeurs non vides ; avec --hors T1/T2, celle du reste de la fenêtre, hors du moment lu : utile quand un épisode
|
||||
long fausse la médiane) et à son bruit propre (médiane des écarts entre deux mesures consécutives non vides, hors --hors).
|
||||
1. Un tableau par colonne : niveau, bruit, et le plus grand saut d'une mesure à la suivante (valeur, en bruits,
|
||||
les deux instants).
|
||||
2. Les plages où la colonne s'écarte de son niveau de plus de --k bruits : début et fin (première et dernière
|
||||
mesure hors niveau), nombre de mesures hors niveau, valeur extrême (écart signé au niveau, en unités et en
|
||||
bruits) et son instant. Deux plages du même sens séparées de moins de --fusion (défaut 1h) n'en font qu'une
|
||||
(un écart vers le bas puis vers le haut font deux plages) ; les mesures rejetées (colonne vide) ne coupent pas
|
||||
une plage. Colonne « rejetées » : combien des mesures de la plage sont rejetées par la station (error_value
|
||||
au-dessus du seuil), et « extrême rejetée » si l'extrême l'est ; un saut dont un bout est rejeté le dit.
|
||||
corr_x, corr_y d'une mesure rejetée sont vides, références comprises (donnees.charger). Une plage qui touche le bord de la fenêtre est datée au
|
||||
bord (le niveau est celui de la fenêtre : un palier durable peut faire de l'autre moitié la « plage »).
|
||||
Avec --min-mesures N, seules les plages d'au moins N mesures hors niveau sont imprimées (leur nombre total aussi).
|
||||
Avec --glissant N (un entier : N mesures non vides de part et d'autre) ou --glissant DUREE (6h, 1d : les mesures
|
||||
à moins de DUREE avant et après), le niveau de chaque mesure est la médiane de ses voisines, sans elle (niveau
|
||||
local) : une dérive longue ou un palier suivent le niveau, seuls restent les écarts plus brefs que la fenêtre.
|
||||
La colonne « niveau » du tableau 1 reste la médiane de la fenêtre ; le bruit ne change pas.
|
||||
3. Avec --instants N : les instants où au moins N capteurs sont hors niveau (sur l'une des colonnes), avec, pour
|
||||
chacun, les capteurs et l'écart en bruits (cx corr_x, cy corr_y, ev error_value, sinon le nom de la colonne),
|
||||
les capteurs rejetés à cet instant (parmi --capteurs : en retirer les capteurs toujours rejetés allège la liste),
|
||||
et chaque référence de la station, --capteurs ou non : error_value (« r » si rejetée) / inlier (« - » vide).
|
||||
Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict.
|
||||
"""
|
||||
import argparse
|
||||
import bisect
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
from donnees import charger, est_reference, filtrer, instant, iso, rejetee
|
||||
from resume import COLONNES, bruit_propre, duree
|
||||
|
||||
ABREGE = {"corr_x": "cx", "corr_y": "cy", "error_value": "ev"}
|
||||
|
||||
|
||||
def locaux(ms, g):
|
||||
"""Niveau local de chaque mesure (t, v) : médiane des voisines non vides, sans elle ; g entier (mesures de part et
|
||||
d'autre) ou timedelta (mesures à moins de g) ; None sans voisine."""
|
||||
ts, vs = [t for t, _ in ms], [v for _, v in ms]
|
||||
out = []
|
||||
for i, t in enumerate(ts):
|
||||
lo, hi = (max(0, i - g), i + g + 1) if isinstance(g, int) else (bisect.bisect_left(ts, t - g), bisect.bisect_right(ts, t + g))
|
||||
w = vs[lo:i] + vs[i + 1:hi]
|
||||
out.append(statistics.median(w) if w else None)
|
||||
return out
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--colonnes", default="error_value,corr_x,corr_y")
|
||||
a.add_argument("--k", type=float, default=5, help="écart au niveau compté, en bruits propres du capteur")
|
||||
a.add_argument("--fusion", default="1h", type=duree, help="deux plages séparées de moins que cela n'en font qu'une")
|
||||
a.add_argument("--min-mesures", type=int, default=1, help="n'imprime que les plages d'au moins N mesures hors niveau")
|
||||
a.add_argument("--hors", help="T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)")
|
||||
a.add_argument("--glissant", type=lambda x: int(x) if x.isdigit() else duree(x),
|
||||
help="N (mesures de part et d'autre) ou durée (6h, 1d) : niveau local, médiane des voisines sans la mesure")
|
||||
a.add_argument("--instants", type=int, help="N : instants où au moins N capteurs sont hors niveau, avec rejets et références")
|
||||
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
o = a.parse_args()
|
||||
|
||||
par = charger(o.dossier)
|
||||
if not par:
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
colonnes = o.colonnes.split(",")
|
||||
hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None
|
||||
if hors and len(hors) != 2:
|
||||
sys.exit("--hors attend T1/T2.")
|
||||
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
||||
series = {s: filtrer(par[s], o.debut, o.fin) for s in noms}
|
||||
if not any(series.values()):
|
||||
sys.exit("Aucune mesure dans la fenêtre demandée.")
|
||||
glis = (f"{o.glissant} mesures" if isinstance(o.glissant, int) else f"{int(o.glissant.total_seconds() // 60)} min") if o.glissant is not None else ""
|
||||
par_instant = {} # iso(t) -> ["capteur.col+écart"] (--instants)
|
||||
|
||||
for col in colonnes:
|
||||
print(f"\n== {col} : niveau, bruit, plus grand saut d'une mesure à la suivante ==")
|
||||
print(f"{'capteur':9}{'n':>5}{'niveau':>10}{'bruit':>10}{'saut':>10}{'(bruits)':>9} entre")
|
||||
plages = []
|
||||
for s in noms:
|
||||
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
|
||||
rej = {m["t"] for m in series[s] if rejetee(m)}
|
||||
if len(ms) < 2:
|
||||
print(f"{s:9}{len(ms):5} (moins de 2 valeurs)")
|
||||
continue
|
||||
ref = [x for x in ms if not hors or not hors[0] <= x[0] <= hors[1]]
|
||||
if len(ref) < 2:
|
||||
print(f"{s:9}{len(ms):5} (moins de 2 valeurs hors --hors)")
|
||||
continue
|
||||
niv = statistics.median(v for _, v in ref)
|
||||
sauts = [(b[1] - a_[1], a_[0], b[0]) for a_, b in zip(ms, ms[1:])]
|
||||
bruit = bruit_propre([v for _, v in ref])
|
||||
d, t1, t2 = max(sauts, key=lambda x: abs(x[0]))
|
||||
bru = f"{d / bruit:9.1f}" if bruit else f"{'-':>9}"
|
||||
marque = [iso(x) for x in (t1, t2) if x in rej]
|
||||
print(f"{s:9}{len(ms):5}{niv:10.4g}{bruit:10.3g}{d:+10.4g}{bru} {iso(t1)} et {iso(t2)}"
|
||||
+ (f" (rejetée : {', '.join(marque)})" if marque else ""))
|
||||
if not bruit:
|
||||
continue
|
||||
lv = locaux(ms, o.glissant) if o.glissant is not None else [niv] * len(ms)
|
||||
groupe = [] # (t, écart au niveau)
|
||||
for (t, v), n in zip(ms + [(None, 0)], lv + [None]):
|
||||
if t is not None and n is not None and abs(v - n) > o.k * bruit:
|
||||
if groupe and (t - groupe[-1][0] > o.fusion or (v > n) != (groupe[-1][1] > 0)): # même sens seul
|
||||
plages.append((s, groupe, bruit, rej))
|
||||
groupe = []
|
||||
groupe.append((t, v - n))
|
||||
par_instant.setdefault(iso(t), {}).setdefault(s, []).append(f"{ABREGE.get(col, col)}{(v - n) / bruit:+.0f}")
|
||||
elif t is None and groupe:
|
||||
plages.append((s, groupe, bruit, rej))
|
||||
toutes = len(plages)
|
||||
plages = [p for p in plages if len(p[1]) >= o.min_mesures]
|
||||
print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' glissant ±' + glis + ' (médiane des voisines)' if glis else ''}{' (niveau hors ' + o.hors + ')' if hors and not glis else ''}{' (bruit hors ' + o.hors + ')' if hors and glis else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)"
|
||||
+ (f" ; {len(plages)} d'au moins {o.min_mesures} mesures sur {toutes}" if o.min_mesures > 1 else ""))
|
||||
print(f"{'capteur':9}{'début':<18}{'fin':<18}{'mesures':>8}{'extrême':>10}{'(bruits)':>9} {'à':<17}{'rejetées':>9}")
|
||||
for s, g, bruit, rej in plages:
|
||||
t, d = max(g, key=lambda x: abs(x[1]))
|
||||
print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{d:+10.4g}{d / bruit:9.1f} {iso(t):<17}"
|
||||
f"{sum(x[0] in rej for x in g):9}{' extrême rejetée' if t in rej else ''}")
|
||||
if not plages:
|
||||
print("(aucune)")
|
||||
|
||||
if o.instants is not None:
|
||||
refs = sorted(s for s in par if est_reference(par[s]))
|
||||
rej_t, ref_t = {}, {s: {} for s in refs}
|
||||
for s in set(noms) | set(refs):
|
||||
for m in filtrer(par[s], o.debut, o.fin):
|
||||
if rejetee(m) and s in noms:
|
||||
rej_t.setdefault(iso(m["t"]), []).append(s)
|
||||
if s in ref_t:
|
||||
ref_t[s][iso(m["t"])] = m
|
||||
f = lambda v, fmt: "-" if v is None else format(v, fmt)
|
||||
lignes = [(t, c) for t, c in sorted(par_instant.items()) if len(c) >= o.instants]
|
||||
print(f"\nInstants où au moins {o.instants} capteurs sont à plus de {o.k:g} bruits du niveau{' glissant ±' + glis if glis else ''} "
|
||||
f"({', '.join(colonnes)}) : {len(lignes)} sur {len(par_instant)} instants avec au moins un capteur hors niveau")
|
||||
print("instant n capteurs hors niveau (écart en bruits) | rejetés | références : error_value (r rejetée) / inlier")
|
||||
for t, c in lignes:
|
||||
r = " ".join(f"{s} {f(ref_t[s][t]['error_value'], '.3g')}{'r' if rejetee(ref_t[s][t]) else ''}/{f(ref_t[s][t]['inlier'], 'g')}"
|
||||
for s in refs if t in ref_t[s])
|
||||
print(f"{t} {len(c):3} {' '.join(s + '.' + ','.join(v) for s, v in c.items())} | {','.join(rej_t.get(t, [])) or '-'} | {r or '-'}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in new issue
Block a user