"""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 : docs/displacement/domaine/carte-des-evenements.md, section 4). Chaque épisode reçoit sa catégorie d'après son détecteur et son label. Un saut revenu à la normale qui chevauche une perte de visibilité, un passage ou une turbulence y est absorbé ; un saut qui dure ou trop récent pour savoir ne l'est jamais. 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 vues-deplacements/journal/categories.py (une ligne par événement) """ import importlib.util import os import sys from datetime import datetime, timedelta from pathlib import Path sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils")) from donnees import charger # 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_perdue": {"label": "Loss of visibility", "ignore": True, "process": "images"}, "passage": {"label": "Passing obstacle", "ignore": True, "process": "images"}, "cible_masquee": {"label": "Target hidden", "ignore": True, "process": "images"}, "turbulence": {"label": "Heat haze", "ignore": None, "process": "aucun"}, "cycle_thermique": {"label": "Daily thermal cycle", "ignore": False, "process": "aucun"}, "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"}, } # (détecteur, label de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom LABELS = {("visibilite", "Poor visibility"): "visibilite_perdue", ("visibilite", "Brief obstruction"): "passage", ("visibilite", "Target obscured"): "cible_masquee", ("sauts", "Sudden jump, back to normal"): "saut_bref", ("sauts", "Lasting shift"): "a_verifier", ("sauts", "Jump, not back yet"): "a_verifier"} KINDS = {"turbulence": "turbulence", "thermique": "cycle_thermique", "trous": "trou"} HOSTS = {"visibilite_perdue", "passage", "turbulence"} # ce qui absorbe un saut revenu à la normale (point 5) 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 vues-deplacements/journal/*.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"])) 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", [])}) text = { "visibilite_perdue": f"The camera could not see {targets(n)} clearly" f"{', including the reference targets' if references & set(sensors) else ''}. " "The curves in this period are not reliable: ignore them.", "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.", "cycle_thermique": "The structure and the camera warm up during the day and cool down at night. " "This wave comes back every day: 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()} 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, et un détecteur inconnu : le texte du détecteur 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"])) return {"start": min(e["start"] for e in groupe), "end": max(e["end"] for e in groupe), "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"]) hosts = [e for e in eps if categorie(e) in HOSTS] host = {id(e): next((h for h in hosts if overlap(e, 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) if prev and datetime.fromisoformat(g[0]["start"]) - datetime.fromisoformat(max(e["end"] for e in prev)) < MERGE: prev += g else: merged.append(g) return sorted((evenement(g, references) for g in merged), key=lambda v: v["start"]) def evenements(mesures): """Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal.""" episodes = [] for mod in detecteurs(): try: episodes += 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__": for v in evenements(charger(sys.argv[1])): print(v["start"], "→", v["end"], f"{v['category']:<17}", "grisé" if v["ignore"] else "gardé", 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 "—")