Events: read-event skill to consult the base (D-085), cases renamed events E-xxx (D-086)

- read-event: map and index first, then the card of close events only,
  then their data with the reading tools; never all cards at once.
  Diagnostic agent, critiquer-lot and builder point to it; the index
  header too. Signature length: about 250 characters, a guideline.
- "Cas" becomes "event": events/E-xxx/event.md, skills new-event,
  review-event, anonymize-event.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-29 07:25:29 +01:00
1 parent 4d99585474
commit 446fde3192
1206 files changed
+2172 -2129

No files matched your search

@@ -0,0 +1,230 @@
"""Copie les données d'un event dans son dossier et l'anonymise : la station prend le numéro de l'event, ses capteurs
des codes stables (D-049, D-050).
Usage :
python3 .claude/skills/anonymize-event/anonymiser.py data/<STATION>/ events/E-xxx/ [--du T] [--au T]
[--etiquettes <lot>/etiquettes.json]
copie displacement/, camera/ (pompage) et images/ de la station dans l'event, noms codés dans les CSV et les noms de fichiers ;
avec --du / --au (2026-10-07T12:00Z), seulement les lignes et les images de [du, au) : un event n'a pas besoin
des centaines d'images d'un long export (event appris par la boucle, D-057) ;
avec --etiquettes, les moments de l'analyste qui touchent [du, au), bornés à la fenêtre et codés, deviennent
etiquettes.json de l'event : son diagnostic à la création, que le benchmark compare aux détecteurs (point 48) ;
etiquetage.md, à côté, dit d'où ils viennent et les montre en tableau ;
dans les .md, .csv et .json de l'event et events/INDEX.md, data/<STATION>/ devient le dossier de l'event et chaque nom son code ;
échoue s'il reste un nom réel
python3 .claude/skills/anonymize-event/anonymiser.py --test
Codes : la station devient E-xxx ; R1, R2... pour les références et C1, C2... pour les cibles, par station.
Le registre (registre.csv, à côté) ne fait que grandir : un capteur garde son code d'un event à l'autre, et une ligne
<station>,<station>,E-xxx dit de quelle station vient chaque event.
"""
import csv
import json
import os
import re
import shutil
import sys
ICI = os.path.dirname(os.path.abspath(__file__))
RACINE = os.path.normpath(os.path.join(ICI, "..", "..", ".."))
REGISTRE = os.path.join(ICI, "registre.csv")
INDEX = os.path.join(RACINE, "events", "INDEX.md")
DONNEES = ("displacement", "camera", "images") # ce que lisent les outils, et les poses de la caméra (pompage) ;
# le reste de data/<STATION>/ ne suit pas
sys.path.insert(0, os.path.join(RACINE, "agent-tools"))
from donnees import charger, est_reference, heure_image, instant, iso, trouver # noqa: E402
def codes(dossier, event_id):
"""{nom: code} : la station devient event_id, ses capteurs leur code ; un capteur inconnu reçoit le code suivant,
ajouté au registre avec la ligne station → event."""
station = os.path.basename(os.path.normpath(dossier))
par = charger(dossier)
if not par:
sys.exit(f"Aucun export « advanced » dans {dossier}.")
lignes = list(csv.DictReader(open(REGISTRE, newline=""))) if os.path.exists(REGISTRE) else []
capteurs = {(l["station"], l["nom"]): l["code"] for l in lignes if l["station"] != l["nom"]}
nouveaux = []
if not any(l["station"] == l["nom"] == station and l["code"] == event_id for l in lignes):
nouveaux.append((station, station, event_id))
for prefixe, reference in (("R", True), ("C", False)):
pris = {c for (s, _), c in capteurs.items() if s == station and c[0] == prefixe}
noms = sorted(x for x in par if est_reference(par[x]) == reference and (station, x) not in capteurs)
# un nom qui a déjà la forme d'un code de son rôle (R1 pour une référence) le garde : le recoder ferait de
# ce code un nom réel, recodé à chaque passage
gardes = [x for x in noms if re.fullmatch(prefixe + r"\d+", x) and x not in pris]
nouveaux += [(station, x, x) for x in gardes]
n = max((int(c[1:]) for c in pris | set(gardes)), default=0)
for nom in noms:
if nom not in gardes:
n += 1
nouveaux.append((station, nom, f"{prefixe}{n}"))
if nouveaux:
with open(REGISTRE, "a", newline="") as f:
w = csv.writer(f)
if not lignes:
w.writerow(("station", "nom", "code"))
w.writerows(nouveaux)
capteurs.update({(s, nom): c for s, nom, c in nouveaux if s != nom})
return station, {**{nom: c for (s, nom), c in capteurs.items() if s == station}, station: event_id}
def motif(table, station, casse=False):
"""Les noms, du plus long au plus court, bornés par un caractère non alphanumérique (« _ » compris : un nom
collé dans un nom de fichier ou de colonne est trouvé, mais BJ_C ne l'est pas dans PBJ_C). La station accepte
espace ou « _ » et toute casse (PS_DES_COUDRES, « PS des Coudres »)."""
parties = []
for nom in sorted(table, key=len, reverse=True):
p = re.escape(nom)
parties.append(f"(?i:{p.replace('_', '[ _]')})" if nom == station else p)
return re.compile(("(?i)" if casse else "") + r"(?<![A-Za-z0-9])(" + "|".join(parties) + r")(?![A-Za-z0-9])")
def remplacer(texte, table, station):
return motif(table, station).sub(lambda m: table.get(m.group(1), table[station]), texte)
def lire(p):
with open(p, newline="") as f:
return f.read()
def ecrire(p, texte):
with open(p, "w", newline="") as f:
f.write(texte)
def dans(t, du, au):
return (du is None or t >= du) and (au is None or t < au)
def filtrer_csv(texte, du, au):
"""L'en-tête et les lignes dont le premier champ (l'heure, UTC) tombe dans [du, au), gardées à l'identique."""
if du is None and au is None:
return texte
lignes = texte.splitlines(keepends=True)
return "".join(lignes[:1] + [l for l in lignes[1:] if l.strip() and dans(instant(l.split(",", 1)[0]), du, au)])
def garder_image(nom, du, au):
"""Vrai si l'heure du nom (D-045) tombe dans [du, au) ; une image sans heure lisible est gardée."""
t = heure_image(nom)
return t is None or dans(t, du, au)
def etiquettes_de_l_event(chemin, du, au):
"""Étiquettes d'un lot (D-061) -> texte JSON de celles de l'event : les moments qui touchent [du, au), bornés à la
fenêtre ; les noms restent réels (remplacer les code ensuite)."""
with open(chemin, encoding="utf-8") as f:
lot = json.load(f)
a, b = iso(du) if du else lot["debut"], iso(au) if au else lot["fin"]
moments = [dict(m, debut=max(m["debut"], a), fin=min(m["fin"], b))
for m in lot["moments"] if m["fin"] >= a and m["debut"] < b]
return json.dumps(dict(lot, debut=a, fin=b, moments=moments), ensure_ascii=False, indent=1) + "\n"
def etiquetage_md(chemin, texte):
"""Rendu d'étiquetage d'un event appris : d'où viennent ses étiquettes (séance et lot, sans la station, que
l'anonymisation refuse) et le tableau de ses moments, déjà codés (texte : son etiquettes.json)."""
e = json.loads(texte)
lot = os.path.dirname(os.path.abspath(chemin))
seance = os.path.basename(os.path.dirname(lot)).split("_")[0]
lignes = [f"# Étiquetage de {e['station']}", "",
f"Étiquettes de l'analyste de `/boucle`, séance {seance}, {os.path.basename(lot)} (sa lecture : section "
f"« 1. Ma lecture » de `critique.md` du lot), recopiées par `anonymiser.py --etiquettes`, bornées à la "
f"fenêtre de l'event ({e['debut']} → {e['fin']}) et codées (D-069). Pas relues contre la fiche : la fiche de l'"
"event vient de la même lecture.", "",
"| Début | Fin | Capteurs | Catégorie | Événement | Preuve | Description |", "|---|---|---|---|---|---|---|"]
lignes += [f"| {m['debut']} | {m['fin']} | {', '.join(m['capteurs']) or 'tous'} | {m['categorie']} | "
f"{m.get('evenement') or '—'} | {m.get('preuve', '—')} | {m.get('description', '').replace('|', '/')} |"
for m in e["moments"]]
return "\n".join(lignes) + "\n"
def anonymiser(dossier, event, du=None, au=None, etiquettes=None):
event_id = os.path.basename(os.path.normpath(event))
if not re.fullmatch(r"E-\d{3}", event_id):
sys.exit(f"Le dossier de l'event doit s'appeler E-xxx : {event}")
station, table = codes(dossier, event_id)
# le nom de la caméra en tête des exports peut différer du dossier (« Carrière X (B) » dans data/NORDEND/)
for p in trouver(dossier)["advanced"]:
table.setdefault(os.path.basename(p).split("_advanced_")[0], event_id)
for sous in DONNEES:
for r, _, fs in os.walk(os.path.join(dossier, sous)):
for f in fs:
src = os.path.join(r, f)
dst = os.path.join(event, remplacer(os.path.relpath(src, dossier), table, station))
os.makedirs(os.path.dirname(dst), exist_ok=True)
if f.endswith(".csv"):
texte = filtrer_csv(lire(src), du, au)
if len(texte.splitlines()) > 1: # un CSV par jour hors de la fenêtre : rien, pas un en-tête seul
ecrire(dst, remplacer(texte, table, station))
elif garder_image(f, du, au):
shutil.copy2(src, dst)
if etiquettes: # le diagnostic de l'event à sa création (point 48 : benchmark des détecteurs), et d'où il vient
texte = remplacer(etiquettes_de_l_event(etiquettes, du, au), table, station)
ecrire(os.path.join(event, "etiquettes.json"), texte)
ecrire(os.path.join(event, "etiquetage.md"), remplacer(etiquetage_md(etiquettes, texte), table, station))
def textes():
return [os.path.join(r, f) for r, _, fs in os.walk(event) for f in fs if f.endswith((".md", ".csv", ".json"))] + [INDEX]
chemin = re.compile(rf"data/{re.escape(station)}/?")
for p in textes():
avant = lire(p)
apres = remplacer(chemin.sub(f"events/{event_id}/", avant), table, station)
if apres != avant:
ecrire(p, apres)
reste = motif({n: c for n, c in table.items() if n != c}, station, casse=True)
residus = [f"{p} : {m.group(1)}" for p in textes() for m in reste.finditer(lire(p))]
residus += [os.path.join(r, f) for r, ds, fs in os.walk(event) for f in fs + ds if reste.search(f)]
if residus:
sys.exit("Noms réels restants (casse différente ?) :\n " + "\n ".join(residus[:20]))
print(", ".join(f"{n} → {c}" for n, c in sorted(table.items(), key=lambda x: x[1])))
def _test():
t = {"PS_DES_COUDRES": "E-001", "BJ_C": "C1", "PBJ_C": "C7", "REF_G": "R3"}
f = lambda s: remplacer(s, t, "PS_DES_COUDRES") # noqa: E731
assert f("PBJ_C et BJ_C") == "C7 et C1"
assert f("timestamp,BJ_C_vertical_displacement,PBJ_C_error") == "timestamp,C1_vertical_displacement,C7_error"
assert f("PS des Coudres_advanced_20261008.csv, REF_GX") == "E-001_advanced_20261008.csv, REF_GX"
t["Carrière X (B)"] = "E-001"
assert f("displacement/Carrière X (B)_20260728_to_20260731_1hour.csv") == "displacement/E-001_20260728_to_20260731_1hour.csv"
t.update({"R1": "R1", "PA1_2": "R4"}) # un nom en forme de code le garde : un second passage ne change rien
assert f(f("R1,PA1_2")) == "R1,R4"
du, au = instant("2026-10-07T12:00Z"), instant("2026-10-08T00:00Z")
txt = "time_utc,x\n2026-10-07 11:59:00+00:00,1\n2026-10-07 12:00:09+00:00,2\n2026-10-08 00:00:00+00:00,3\n"
assert filtrer_csv(txt, du, au) == "time_utc,x\n2026-10-07 12:00:09+00:00,2\n"
assert filtrer_csv(txt, None, None) == txt
assert filtrer_csv("timestamp,a\r\n2026-10-07 13:00:00,1\r\n", du, au) == "timestamp,a\r\n2026-10-07 13:00:00,1\r\n"
assert garder_image("20261007T1200Z_1.jpg", du, au) and not garder_image("20261008T0000Z_2.jpg", du, au)
assert garder_image("sans_heure.jpg", du, au)
import tempfile
with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False, encoding="utf-8") as f:
json.dump({"station": "S", "debut": "2026-10-07T00:00Z", "fin": "2026-10-09T00:00Z", "moments": [
{"debut": "2026-10-07T10:00Z", "fin": "2026-10-07T13:00Z", "capteurs": ["BJ_C"], "categorie": "passage"},
{"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:00Z", "capteurs": []}]}, f)
e = json.loads(etiquettes_de_l_event(f.name, du, au))
os.remove(f.name)
assert (e["debut"], e["fin"]) == ("2026-10-07T12:00Z", "2026-10-08T00:00Z")
assert [(m["debut"], m["fin"]) for m in e["moments"]] == [("2026-10-07T12:00Z", "2026-10-07T13:00Z")]
md = etiquetage_md("/x/2026-10-26T1414Z_S/lot-01/etiquettes.json", json.dumps(e))
assert "séance 2026-10-26T1414Z, lot-01" in md and "| BJ_C |" in md and "_S" not in md
print("ok")
if __name__ == "__main__":
if sys.argv[1:] == ["--test"]:
_test()
else:
import argparse
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("dossier")
p.add_argument("event")
p.add_argument("--du", type=instant, help="premier instant gardé, UTC")
p.add_argument("--au", type=instant, help="premier instant exclu, UTC")
p.add_argument("--etiquettes", help="etiquettes.json du lot : ses moments dans [du, au) deviennent ceux de l'event")
a = p.parse_args()
anonymiser(a.dossier, a.event, a.du, a.au, a.etiquettes)