213 lines
14 KiB
Python
213 lines
14 KiB
Python
"""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-24 : events/carte-des-evenements.md, section 4).
|
|
|
|
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) :
|
|
Target issue (`cible_a_probleme` : 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
|
|
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
|
|
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
|
|
(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.
|
|
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement)
|
|
... <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)
|
|
"""
|
|
import importlib.util
|
|
import os
|
|
import sys
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
|
from donnees import charger, iso # noqa: E402
|
|
|
|
# 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 = {
|
|
"visibilite_reduite": {"label": "Reduced visibility", "ignore": False, "process": "images"}, # en retrait (point 38)
|
|
"visibilite_nulle": {"label": "No visibility", "ignore": True, "process": "images"},
|
|
"passage": {"label": "Passing obstacle", "ignore": True, "process": "images"},
|
|
"cible_masquee": {"label": "Target hidden", "ignore": True, "process": "images"},
|
|
"cible_a_probleme": {"label": "Target issue", "ignore": True, "process": "images"}, # Target issue (D-074)
|
|
"turbulence": {"label": "Heat haze", "ignore": None, "process": "aucun"},
|
|
"dilatation_thermique": {"label": "Thermal expansion", "ignore": False, "process": "aucun"}, # effet périodique
|
|
"contraction_thermique": {"label": "Thermal contraction", "ignore": False, "process": "aucun"}, # (point 41)
|
|
"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"},
|
|
"derive_lente": {"label": "Slow drift", "ignore": False, "process": "verifier"}, # sous-groupe d'À vérifier (D-074)
|
|
}
|
|
# (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",
|
|
("sauts", "Jump, not back yet", None): "a_verifier", ("sauts", "Large shift", None): "a_verifier",
|
|
("sauts", "Target flipping", None): "cible_a_probleme",
|
|
("thermique", "Thermal expansion", None): "dilatation_thermique",
|
|
("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_a_probleme", "derive": "derive_lente"}
|
|
HOSTS = {"visibilite_reduite", "visibilite_nulle", "passage", "turbulence", "dilatation_thermique",
|
|
"contraction_thermique"} # absorbent un saut revenu (point 5 ; la vague thermique : boucle NIEDERHORN, lot 01)
|
|
MERGE = timedelta(hours=1) # même catégorie à moins d'une heure : un seul événement (point 5, 2026-10-24)
|
|
|
|
|
|
def detecteurs():
|
|
"""Modules de detectors/*.py qui ont detect ; un fichier qui ne se charge pas est sauté avec un
|
|
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):
|
|
return LABELS.get((ep["kind"], ep["label"], ep.get("level"))) or KINDS.get(ep["kind"]) or ep["kind"]
|
|
|
|
|
|
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", [])})
|
|
refs = ", including the reference targets" if references & set(sensors) else ""
|
|
camera = groupe[0]["label"].startswith("Camera")
|
|
large = any(e["label"] == "Large shift" for e in groupe)
|
|
text = {
|
|
"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.",
|
|
"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.",
|
|
"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.",
|
|
"saut_bref": f"{targets(n).capitalize()} jumped and came back. This is not a movement: ignore it.",
|
|
"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
|
|
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.",
|
|
}.get(cat, groupe[0]["text"]) # trou, cible à problème, dérive, détecteur inconnu : le texte du détecteur
|
|
if cat == "cible_a_probleme":
|
|
text += f" Ignore {'its curve' if one else 'their curves'} in this period and look at the images of the target."
|
|
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"]))
|
|
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,
|
|
"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"])
|
|
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)]
|
|
# la vague thermique n'absorbe qu'en dernier (un saut d'un passage ou d'une pluie va à eux), et que les sauts de
|
|
# plusieurs cibles : la vague les fait bouger ensemble, une cible seule qui saute n'est pas la vague (C2 de E-003)
|
|
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"}
|
|
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)
|
|
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:
|
|
prev += g
|
|
else:
|
|
merged.append(g)
|
|
return sorted((evenement(g, references) for g in merged), key=lambda v: v["start"])
|
|
|
|
|
|
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."""
|
|
episodes = []
|
|
for mod in detecteurs():
|
|
try:
|
|
episodes += mod.detect(mesures, fin) if mod.__name__ == "journal_trous" else mod.detect(mesures)
|
|
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__":
|
|
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])}
|
|
evs = [v for v in evenements(tranche, b) if v["end"] >= iso(t)] if tranche else []
|
|
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é",
|
|
f"| {v['episodes'][0]['kind']}", # le détecteur, pour que l'analyste le nomme (boucle, 2026-10-26)
|
|
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
|