2026-10-26 14:55:46 +01:00
"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic.
2026-10-28 16:36:45 +01:00
Usage : python3 agent-tools/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y]
2026-11-03 16:56:59 +01:00
[--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N]
[--capteurs A,B] [--debut ...] [--fin ...]
2026-10-26 14:55:46 +01:00
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
2026-10-26 16:48:13 +01:00
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
2026-10-27 10:02:44 +01:00
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
2026-10-26 14:55:46 +01:00
bord (le niveau est celui de la fenêtre : un palier durable peut faire de l'autre moitié la « plage »).
2026-10-27 10:19:05 +01:00
Avec --min-mesures N, seules les plages d'au moins N mesures hors niveau sont imprimées (leur nombre total aussi).
2026-11-03 16:56:59 +01:00
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).
2026-10-26 14:55:46 +01:00
Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict.
"""
import argparse
2026-11-03 16:56:59 +01:00
import bisect
2026-10-26 14:55:46 +01:00
import statistics
import sys
2026-10-27 10:02:44 +01:00
from donnees import charger , est_reference , filtrer , instant , iso , rejetee
2026-10-26 14:55:46 +01:00
from resume import COLONNES , duree
2026-11-03 16:56:59 +01:00
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
2026-10-26 14:55:46 +01:00
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" )
2026-10-27 10:19:05 +01:00
a . add_argument ( "--min-mesures" , type = int , default = 1 , help = "n'imprime que les plages d'au moins N mesures hors niveau" )
2026-10-26 14:55:46 +01:00
a . add_argument ( "--hors" , help = "T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)" )
2026-11-03 16:56:59 +01:00
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" )
2026-10-26 14:55:46 +01:00
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." )
2026-11-03 16:56:59 +01:00
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)
2026-10-26 14:55:46 +01:00
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 ]
2026-10-27 10:02:44 +01:00
rej = { m [ "t" ] for m in series [ s ] if rejetee ( m )}
2026-10-26 14:55:46 +01:00
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 = statistics . median ( abs ( b [ 1 ] - a_ [ 1 ]) for a_ , b in zip ( ref , ref [ 1 :]))
d , t1 , t2 = max ( sauts , key = lambda x : abs ( x [ 0 ]))
bru = f " { d / bruit : 9.1f } " if bruit else f " { '-' : >9 } "
2026-10-27 10:02:44 +01:00
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 "" ))
2026-10-26 14:55:46 +01:00
if not bruit :
continue
2026-11-03 16:56:59 +01:00
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 ))
2026-10-26 14:55:46 +01:00
groupe = []
2026-11-03 16:56:59 +01:00
groupe . append (( t , v - n ))
par_instant . setdefault ( iso ( t ), {}) . setdefault ( s , []) . append ( f " { ABREGE . get ( col , col ) }{ ( v - n ) / bruit : +.0f } " )
2026-10-26 14:55:46 +01:00
elif t is None and groupe :
2026-11-03 16:56:59 +01:00
plages . append (( s , groupe , bruit , rej ))
2026-10-27 10:19:05 +01:00
toutes = len ( plages )
plages = [ p for p in plages if len ( p [ 1 ]) >= o . min_mesures ]
2026-11-03 16:56:59 +01:00
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)"
2026-10-27 10:19:05 +01:00
+ ( f " ; { len ( plages ) } d'au moins { o . min_mesures } mesures sur { toutes } " if o . min_mesures > 1 else "" ))
2026-10-27 10:02:44 +01:00
print ( f " { 'capteur' : 9 }{ 'début' : <18 }{ 'fin' : <18 }{ 'mesures' : >8 }{ 'extrême' : >10 }{ '(bruits)' : >9 } { 'à' : <17 }{ 'rejetées' : >9 } " )
2026-11-03 16:56:59 +01:00
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 } "
2026-10-27 10:02:44 +01:00
f " { sum ( x [ 0 ] in rej for x in g ) : 9 }{ ' extrême rejetée' if t in rej else '' } " )
2026-10-26 14:55:46 +01:00
if not plages :
print ( "(aucune)" )
2026-11-03 16:56:59 +01:00
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 " \n Instants 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 '-' } " )
2026-10-26 14:55:46 +01:00
if __name__ == "__main__" :
main ()