2026-10-24 11:02:38 +02:00
"""Journal du matin : des épisodes des détecteurs aux événements catégorisés (point 6 du plan ; catégories validées le
2026-10-28 16:32:06 +01:00
2026-10-24 : events/carte-des-evenements.md, section 4).
2026-10-24 11:02:38 +02:00
2026-10-27 09:28:29 +01:00
Chaque épisode reçoit sa catégorie d'après son détecteur et son label ; catégories du terrain (D-074, 2026-10-27) :
Cible défaillante (`cible_degradee` : degradee, et sauts « Target flipping »), la dérive lente (derive) et le gros saut
(sauts « Large shift ») sous « À vérifier », l'effet thermique de la caméra (thermique « Camera thermal … »). Un saut revenu à la normale qui chevauche une
2026-10-27 10:59:23 +01:00
perte de visibilité, un passage, une turbulence ou, à défaut et s'il touche plusieurs cibles, un effet thermique y est
absorbé ; un saut qui dure ou trop récent pour savoir ne l'est
2026-10-24 12:22:06 +02:00
jamais ; une turbulence qui chevauche un saut à vérifier n'est pas gardée (un vrai mouvement agite aussi les courbes :
le matin du mouvement de CLARIDEN, point 14 du plan). Deux événements de même catégorie à moins d'une heure n'en font
qu'un. Chaque événement reçoit sa phrase
2026-10-24 11:02:38 +02:00
(point 9, validées le 2026-10-24) : ce qui s'est passé et quoi en faire, sans conditionnel ; la cause n'est dite que si la
catégorie l'établit, sinon les images la montrent. Pas de fonction detect : le chargeur ne prend pas ce fichier pour un
détecteur.
2026-10-28 17:19:51 +01:00
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement)
2026-10-24 14:31:42 +02:00
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot, point 30 :
chaque tranche de 3 jours classée seule, avec les jours d'historique d'avant s'ils existent ; seuls les événements
qui touchent la tranche sont montrés ; « rien » pour une tranche calme)
2026-10-24 11:02:38 +02:00
"""
import importlib.util
import os
import sys
2026-10-24 14:31:42 +02:00
from datetime import datetime , timedelta , timezone
2026-10-24 11:02:38 +02:00
from pathlib import Path
2026-10-28 17:19:51 +01:00
sys . path . insert ( 0 , os . path . join ( os . path . dirname ( os . path . abspath ( __file__ )), ".." , "agent-tools" ))
2026-10-24 14:31:42 +02:00
from donnees import charger , iso # noqa: E402
2026-10-24 11:02:38 +02:00
# ignore : zone grisée (None : comme le dit le détecteur, la turbulence n'est grisée que forte) ; process : bouton
# Images, rien, ou Images et lien vers Diagnosis. L'ordre est celui des lignes de la frise.
CATEGORIES = {
2026-10-24 12:22:06 +02:00
"visibilite_reduite" : { "label" : "Reduced visibility" , "ignore" : False , "process" : "images" }, # en retrait (point 38)
"visibilite_nulle" : { "label" : "No visibility" , "ignore" : True , "process" : "images" },
2026-10-24 11:02:38 +02:00
"passage" : { "label" : "Passing obstacle" , "ignore" : True , "process" : "images" },
"cible_masquee" : { "label" : "Target hidden" , "ignore" : True , "process" : "images" },
2026-10-27 09:28:29 +01:00
"cible_degradee" : { "label" : "Faulty target" , "ignore" : True , "process" : "images" }, # Cible défaillante (D-074)
2026-10-24 11:02:38 +02:00
"turbulence" : { "label" : "Heat haze" , "ignore" : None , "process" : "aucun" },
2026-10-24 12:22:06 +02:00
"dilatation_thermique" : { "label" : "Thermal expansion" , "ignore" : False , "process" : "aucun" }, # effet périodique
"contraction_thermique" : { "label" : "Thermal contraction" , "ignore" : False , "process" : "aucun" }, # (point 41)
2026-10-24 11:02:38 +02:00
"trou" : { "label" : "No data" , "ignore" : False , "process" : "aucun" },
"saut_bref" : { "label" : "Brief jump" , "ignore" : True , "process" : "images" },
"a_verifier" : { "label" : "Shift to check" , "ignore" : False , "process" : "verifier" },
2026-10-27 09:28:29 +01:00
"derive_lente" : { "label" : "Slow drift" , "ignore" : False , "process" : "verifier" }, # sous-groupe d'À vérifier (D-074)
2026-10-24 11:02:38 +02:00
}
2026-10-24 12:22:06 +02:00
# (détecteur, label, niveau de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom
LABELS = {( "visibilite" , "Poor visibility" , "reduced" ): "visibilite_reduite" ,
( "visibilite" , "Poor visibility" , "none" ): "visibilite_nulle" ,
( "visibilite" , "Brief obstruction" , None ): "passage" , ( "visibilite" , "Target obscured" , None ): "cible_masquee" ,
( "sauts" , "Sudden jump, back to normal" , None ): "saut_bref" , ( "sauts" , "Lasting shift" , None ): "a_verifier" ,
2026-10-27 09:28:29 +01:00
( "sauts" , "Jump, not back yet" , None ): "a_verifier" , ( "sauts" , "Large shift" , None ): "a_verifier" ,
( "sauts" , "Target flipping" , None ): "cible_degradee" ,
2026-10-24 12:22:06 +02:00
( "thermique" , "Thermal expansion" , None ): "dilatation_thermique" ,
2026-10-27 09:28:29 +01:00
( "thermique" , "Thermal contraction" , None ): "contraction_thermique" ,
( "thermique" , "Camera thermal expansion" , None ): "dilatation_thermique" ,
( "thermique" , "Camera thermal contraction" , None ): "contraction_thermique" }
KINDS = { "turbulence" : "turbulence" , "trous" : "trou" , "degradee" : "cible_degradee" , "derive" : "derive_lente" }
2026-10-27 10:59:23 +01:00
HOSTS = { "visibilite_reduite" , "visibilite_nulle" , "passage" , "turbulence" , "dilatation_thermique" ,
"contraction_thermique" } # absorbent un saut revenu (point 5 ; la vague thermique : boucle NIEDERHORN, lot 01)
2026-10-24 11:02:38 +02:00
MERGE = timedelta ( hours = 1 ) # même catégorie à moins d'une heure : un seul événement (point 5, 2026-10-24)
def detecteurs ():
2026-10-28 17:19:51 +01:00
"""Modules de detectors/*.py qui ont detect ; un fichier qui ne se charge pas est sauté avec un
2026-10-24 11:02:38 +02:00
message."""
mods = []
for path in sorted ( Path ( __file__ ) . resolve () . parent . glob ( "*.py" )):
if path == Path ( __file__ ) . resolve ():
continue
try :
spec = importlib . util . spec_from_file_location ( f "journal_ { path . stem } " , path )
mod = importlib . util . module_from_spec ( spec )
spec . loader . exec_module ( mod )
except Exception as e : # noqa: BLE001 (prototype : un détecteur cassé ne bloque pas la page)
print ( f "Journal : { path . name } sauté ( { type ( e ) . __name__ } : { e } )" , file = sys . stderr )
continue
if hasattr ( mod , "detect" ):
mods . append ( mod )
return mods
def categorie ( ep ):
2026-10-24 12:22:06 +02:00
return LABELS . get (( ep [ "kind" ], ep [ "label" ], ep . get ( "level" ))) or KINDS . get ( ep [ "kind" ]) or ep [ "kind" ]
2026-10-24 11:02:38 +02:00
def overlap ( a , b ):
return a [ "start" ] <= b [ "end" ] and a [ "end" ] >= b [ "start" ] # heures donnees.iso : l'ordre du texte est celui du temps
def targets ( n ):
return "one target" if n == 1 else f " { n } targets"
def phrase ( cat , groupe , sensors , references ):
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24) ; un saut absorbé ajoute qu'il n'est
pas un mouvement."""
n , one = len ( sensors ), len ( sensors ) == 1
sauts = [ e for e in groupe [ 1 :] if categorie ( e ) == "saut_bref" ]
jumped = len ({ s for e in sauts for s in e [ "sensors" ]})
lasting = len ({ s for e in groupe if categorie ( e ) == "a_verifier" for s in e . get ( "lasting" , [])})
2026-10-24 12:22:06 +02:00
refs = ", including the reference targets" if references & set ( sensors ) else ""
2026-10-27 09:28:29 +01:00
camera = groupe [ 0 ][ "label" ] . startswith ( "Camera" )
large = any ( e [ "label" ] == "Large shift" for e in groupe )
2026-10-24 11:02:38 +02:00
text = {
2026-10-24 12:22:06 +02:00
"visibilite_nulle" : f "The camera could not see { targets ( n ) } clearly { refs } . "
"The curves in this period are not reliable: ignore them." ,
"visibilite_reduite" : f "The camera saw { targets ( n ) } less clearly than usual { refs } . "
"The data in this period are less precise: use them with care." ,
2026-10-24 11:02:38 +02:00
"passage" : f "Something passed in front of { targets ( n ) } for a single measurement. Ignore this point on the curves." ,
"cible_masquee" : f " { ', ' . join ( sensors ) } { 'was' if one else 'were' } hidden several times while the targets around "
f " { 'it' if one else 'them' } stayed clear. Ignore { 'its curve' if one else 'their curves' } in this period." ,
"turbulence" : "Warm air made the readings shake. The small fast wiggles are not movement." ,
2026-10-27 09:28:29 +01:00
"dilatation_thermique" : ( "The camera support expands in the day heat; the curves are corrected for it."
if camera else "The structure expands in the day heat." ) + " This daily wave is normal: nothing to do." ,
"contraction_thermique" : ( "The camera support contracts as it cools down; the curves are corrected for it."
if camera else "The structure contracts as it cools down." ) + " This daily wave is normal: nothing to do." ,
2026-10-24 11:02:38 +02:00
"saut_bref" : f " { targets ( n ) . capitalize () } jumped and came back. This is not a movement: ignore it." ,
2026-10-27 09:28:29 +01:00
"a_verifier" : ( f " { targets ( n ) . capitalize () } , most of the targets, shifted together: everything moved." if large
else f " { targets ( n ) . capitalize () } shifted and { 'has' if one else 'have' } not come back yet." if not lasting
2026-10-24 11:02:38 +02:00
else f " { targets ( n ) . capitalize () } shifted and stayed shifted." if lasting == n
else f " { targets ( n ) . capitalize () } shifted; { lasting } of them stayed shifted." )
+ " Check whether the structure moved: look at the images." ,
2026-10-27 09:28:29 +01:00
} . get ( cat , groupe [ 0 ][ "text" ]) # trou, cible défaillante, dérive, détecteur inconnu : le texte du détecteur
if cat == "cible_degradee" :
text += f " Ignore { 'its curve' if one else 'their curves' } in this period and look at the images of the target."
2026-10-24 11:02:38 +02:00
if not jumped :
return text
return text + ( f " The jump of { targets ( jumped ) } in this period is not a movement." if len ( sauts ) == 1
else f " The jumps of { targets ( jumped ) } in this period are not movements." )
def evenement ( groupe , references ):
"""Épisodes d'un même événement, le principal en tête -> événement."""
cat = categorie ( groupe [ 0 ])
c = CATEGORIES . get ( cat , { "label" : groupe [ 0 ][ "label" ], "ignore" : None , "process" : "aucun" })
sensors = [] if any ( not e [ "sensors" ] for e in groupe ) else list ( dict . fromkeys ( s for e in groupe for s in e [ "sensors" ]))
2026-10-24 12:22:06 +02:00
main = [ e for e in groupe if categorie ( e ) == cat ] # la durée est celle des épisodes principaux, pas des sauts absorbés
return { "start" : min ( e [ "start" ] for e in main ), "end" : max ( e [ "end" ] for e in main ), "category" : cat ,
2026-10-24 11:02:38 +02:00
"label" : c [ "label" ], "text" : phrase ( cat , groupe , sensors , references ),
"ignore" : c [ "ignore" ] if c [ "ignore" ] is not None else any ( e [ "ignore" ] for e in groupe if categorie ( e ) == cat ),
"sensors" : sensors , "process" : c [ "process" ], "episodes" : groupe }
def classer ( episodes , references = frozenset ()):
"""Épisodes de tous les détecteurs -> événements triés par début (règles : docstring du module) ; references : les
capteurs global_ref, pour la phrase."""
eps = sorted ( episodes , key = lambda e : e [ "start" ])
2026-10-24 12:22:06 +02:00
checks = [ e for e in eps if categorie ( e ) == "a_verifier" ] # un vrai mouvement n'est jamais pris pour de la turbulence
eps = [ e for e in eps if categorie ( e ) != "turbulence" or not any ( overlap ( e , c ) for c in checks )]
2026-10-27 10:59:23 +01:00
# la vague thermique n'absorbe qu'en dernier (un saut d'un passage ou d'une pluie va à eux), et que les sauts de
2026-10-29 07:25:29 +01:00
# plusieurs cibles : la vague les fait bouger ensemble, une cible seule qui saute n'est pas la vague (C2 de E-003)
2026-10-27 10:59:23 +01:00
thermique = lambda e : categorie ( e ) . endswith ( "_thermique" ) # noqa: E731
hosts = sorted (( e for e in eps if categorie ( e ) in HOSTS ), key = thermique )
host = { id ( e ): next (( h for h in hosts if overlap ( e , h ) and ( len ( e [ "sensors" ]) > 1 or not thermique ( h ))), None )
for e in eps if categorie ( e ) == "saut_bref" }
2026-10-24 11:02:38 +02:00
groupes = { id ( e ): [ e ] for e in eps if not host . get ( id ( e ))}
for e in eps :
if host . get ( id ( e )):
groupes [ id ( host [ id ( e )])] . append ( e )
merged = []
for g in groupes . values ():
prev = next (( m for m in reversed ( merged ) if categorie ( m [ 0 ]) == categorie ( g [ 0 ])), None )
2026-10-24 12:22:06 +02:00
end = max (( e [ "end" ] for e in prev if categorie ( e ) == categorie ( g [ 0 ])), default = None ) if prev else None
if end and datetime . fromisoformat ( g [ 0 ][ "start" ]) - datetime . fromisoformat ( end ) < MERGE :
2026-10-24 11:02:38 +02:00
prev += g
else :
merged . append ( g )
return sorted (( evenement ( g , references ) for g in merged ), key = lambda v : v [ "start" ])
2026-10-26 17:25:49 +01:00
def evenements ( mesures , fin = None ):
"""Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal ; fin : fin
de la fenêtre lue (tri en lot), donnée à trous seul, pour un trou qui la touche."""
2026-10-24 11:02:38 +02:00
episodes = []
for mod in detecteurs ():
try :
2026-10-26 17:25:49 +01:00
episodes += mod . detect ( mesures , fin ) if mod . __name__ == "journal_trous" else mod . detect ( mesures )
2026-10-24 11:02:38 +02:00
except Exception as e : # noqa: BLE001
print ( f "Journal : { mod . __name__ } sauté ( { type ( e ) . __name__ } : { e } )" , file = sys . stderr )
return classer ( episodes , { s for s , ms in mesures . items () if ms [ 0 ][ "pattern_type" ] == "global_ref" })
if __name__ == "__main__" :
2026-10-24 14:31:42 +02:00
import argparse
p = argparse . ArgumentParser ( description = "Une ligne par événement ; --tranche : chaque tranche classée seule." )
p . add_argument ( "dossier" )
p . add_argument ( "--du" , help = "premier jour UTC, AAAA-MM-JJ (défaut : début des données)" )
p . add_argument ( "--au" , help = "dernier jour UTC exclu, AAAA-MM-JJ (défaut : fin des données)" )
p . add_argument ( "--tranche" , type = int , default = 0 , help = "jours par tranche (défaut : un seul passage)" )
# sans historique, une tranche qui commence juste avant un vrai saut le prend pour un saut revenu (PR17 à NORDEND,
# le 08/10 à 02:30 : absorbé dans la buée) ; 3 jours le rendent ; règle de l'utilisateur (2026-10-24) : 3 jours
# d'historique par défaut, dans la boucle comme dans la vraie application
p . add_argument ( "--historique" , type = int , default = 3 , help = "jours de mesures d'avant donnés aux détecteurs (défaut 3)" )
a = p . parse_args ()
mesures = charger ( a . dossier )
ts = [ m [ "t" ] for ms in mesures . values () for m in ms ]
jour = lambda d : datetime . strptime ( d , "%Y-%m- %d " ) . replace ( tzinfo = timezone . utc ) # noqa: E731
debut = jour ( a . du ) if a . du else min ( ts ) . replace ( hour = 0 , minute = 0 , second = 0 , microsecond = 0 )
fin = jour ( a . au ) if a . au else max ( ts ) + timedelta ( seconds = 1 )
t = debut
while t < fin :
b = min ( t + timedelta ( days = a . tranche ), fin ) if a . tranche else fin
h = t - timedelta ( days = a . historique )
tranche = { s : k for s , ms in mesures . items () if ( k := [ m for m in ms if h <= m [ "t" ] < b ])}
2026-10-26 17:25:49 +01:00
evs = [ v for v in evenements ( tranche , b ) if v [ "end" ] >= iso ( t )] if tranche else []
2026-10-24 14:31:42 +02:00
if a . tranche :
print ( f "== { iso ( t ) } → { iso ( b ) } : { len ( evs ) or 'rien' } " )
for v in evs :
print ( v [ "start" ], "→" , v [ "end" ], f " { v [ 'category' ] : <17 } " , "grisé" if v [ "ignore" ] else "gardé" ,
2026-10-26 16:48:13 +01:00
f "| { v [ 'episodes' ][ 0 ][ 'kind' ] } " , # le détecteur, pour que l'analyste le nomme (boucle, 2026-10-26)
2026-10-24 14:31:42 +02:00
f "| { len ( v [ 'sensors' ]) or 'tous les' } capteurs" , "| absorbés :" , ", " . join (
f " { e [ 'kind' ] } { e [ 'start' ][ 5 : 16 ] } " for e in v [ "episodes" ][ 1 :]) or "—" )
t = b