- inventaire.py: what each source contains on the window (filled or empty columns, metric names, images), names and counts only - analyser-lot: step 0 on the data, own scripts in <lot>/outils/, section 3 "Outils" - tool-builder (the optimiser, rewritten): after the analyst, optimises or adds reading tools, never removes; no control yet - /aiguiser skill, reader, corrector and voir.py removed; its sessions and spec stay as history - docs: D-097, specs, CLAUDE.md, run.md, README, plan point 56; the shared files also carry another session's pending edits (D-096 entry, plan points 57 to 67) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
251 lines
13 KiB
Python
251 lines
13 KiB
Python
"""Inventaire d'un dossier de station : ce qui est disponible, ce qui manque.
|
|
|
|
Usage : python3 agent-tools/inventaire.py data/PS_DES_COUDRES/ [--debut T] [--fin T] [--fichiers]
|
|
Les comptes portent sur toute la période. Avec --debut et/ou --fin, une section de plus liste, sur cette fenêtre,
|
|
les pas absents (datés, avec les capteurs qui n'ont pas de mesure) et, par capteur, les mesures rejetées (datées,
|
|
en suites de pas consécutifs ; rejetée : error_value au-dessus du seuil, références comprises), puis le nombre de
|
|
références retenues par la compensation (inlier = 1) à chaque instant et, datées, les suites d'instants où des
|
|
références ne le sont pas (lesquelles, et pourquoi : rejetée, inlier 0, inlier vide). Mouvements de la caméra (camera/) : nombre de poses, période, et les instants de mesure
|
|
sans pose (pas de recalage), sur toute la période puis sur la fenêtre. Avant les comptes, ce que contient chaque source
|
|
(sur la fenêtre, sinon toute la période) : les colonnes de l'export, de la pose et de quality/, remplies ou vides, les noms
|
|
des métriques système de metrics/, les images et les images différentielles. Rend des valeurs, pas de verdict.
|
|
"""
|
|
import argparse
|
|
import collections
|
|
import csv
|
|
import glob
|
|
import os
|
|
import re
|
|
import statistics
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
from donnees import charger, charger_camera, est_reference, filtrer, heure_image, instant, iso, rejetee, trouver
|
|
|
|
METRIQUE_RE = re.compile(r"^(.+?)_(\d{4})_(\d{2})_(\d{2})_\d{2}_\d{2}") # NIEDERHORN_BusCurrent_2026_09_22_00_00 to ….csv
|
|
|
|
|
|
def liste(chemins, tout):
|
|
"""Un dossier de pompage compte des centaines de fichiers : au-delà de 5, le premier et le dernier seulement."""
|
|
if tout or len(chemins) <= 5:
|
|
shown = chemins
|
|
else:
|
|
shown = [chemins[0], chemins[-1]]
|
|
print(f" {len(chemins)} fichiers, du premier au dernier (--fichiers pour la liste complète) :")
|
|
for p in shown:
|
|
print(f" {p}")
|
|
|
|
|
|
def fichiers(f, tout=False):
|
|
print(f"Exports « advanced » (source des mesures) : {len(f['advanced'])}")
|
|
liste(f["advanced"], tout)
|
|
print(f"Exports horaires : {len(f['horaire'])} (non lus par les outils : moyennes horaires, "
|
|
"heure locale sans fuseau ; voir docs/domaine/colonnes-des-deplacements.md)")
|
|
liste(f["horaire"], tout)
|
|
print(f"Mouvements de la caméra (pose à chaque recalage) : {len(f['camera'])}")
|
|
liste(f["camera"], tout)
|
|
print(f"Autres fichiers : {len(f['autres'])}")
|
|
liste(f["autres"], tout)
|
|
|
|
|
|
def remplies(chemins, debut, fin):
|
|
"""CSV d'une source -> (lignes de la fenêtre, {colonne: lignes avec une valeur}), colonnes dans l'ordre des en-têtes."""
|
|
lignes, compte = 0, {}
|
|
for p in chemins:
|
|
with open(p, newline="") as fh:
|
|
r = csv.DictReader(fh)
|
|
for c in r.fieldnames or []:
|
|
if c not in ("", "time_utc", "sensor_name"):
|
|
compte.setdefault(c, 0)
|
|
for row in r:
|
|
if (debut or fin) and filtrer([{"t": instant(row["time_utc"])}], debut, fin) == []:
|
|
continue
|
|
lignes += 1
|
|
for c in compte:
|
|
if (row.get(c) or "").strip():
|
|
compte[c] += 1
|
|
return lignes, compte
|
|
|
|
|
|
def contenu(dossier, f, debut=None, fin=None):
|
|
"""Ce que contient chaque source sur la fenêtre : ses colonnes, remplies ou vides, et les noms des métriques.
|
|
Des noms et des comptes, jamais de valeurs (metrics/ porte des identifiants : SIM_CCID, ip_*)."""
|
|
quoi = "sur la fenêtre" if debut or fin else "sur toute la période"
|
|
print(f"\nCe que contiennent les données, {quoi} (par colonne, les lignes qui ont une valeur ; « vide » : aucune) :")
|
|
autres = collections.defaultdict(list)
|
|
for p in f["autres"]:
|
|
autres[os.path.relpath(p, dossier).split(os.sep)[0]].append(p)
|
|
for titre, chemins in (("Export « advanced »", f["advanced"]), ("Pose de la caméra (camera/)", f["camera"]),
|
|
("Qualité d'image (quality/)", autres.pop("quality", []))):
|
|
if chemins:
|
|
n, compte = remplies(chemins, debut, fin)
|
|
print(f" {titre} : {n} lignes ; " + ", ".join(f"{c} {k}" if k else f"{c} vide" for c, k in compte.items()))
|
|
jours = collections.Counter() # métrique -> jours (un CSV par métrique et par jour) dans la fenêtre
|
|
for p in autres.pop("metrics", []):
|
|
m = METRIQUE_RE.match(os.path.basename(p))
|
|
if not m:
|
|
continue
|
|
jour = datetime(*map(int, m.group(2, 3, 4)), tzinfo=timezone.utc)
|
|
if (debut is None or jour.date() >= debut.date()) and (fin is None or jour.date() <= fin.date()):
|
|
nom = m.group(1)
|
|
jours[nom.split("_", 1)[1] if "_" in nom else nom] += 1
|
|
if jours:
|
|
print(f" Métriques système (metrics/, un CSV par métrique et par jour ; aucun outil ne les lit) : {len(jours)} : "
|
|
+ ", ".join(f"{k} ({n} j)" for k, n in sorted(jours.items())))
|
|
for titre, chemins in (("Images de la caméra", f["images"]),
|
|
("Images différentielles (images_diff/ ; aucun outil ne les lit)", glob.glob(os.path.join(dossier, "images_diff", "*")))):
|
|
heures = [h for h in map(heure_image, chemins) if h and filtrer([{"t": h}], debut, fin)]
|
|
if chemins:
|
|
print(f" {titre} : {len(heures)}")
|
|
if autres:
|
|
print(" Autres : " + ", ".join(f"{k} ({len(v)})" for k, v in sorted(autres.items())))
|
|
|
|
|
|
def images(chemins):
|
|
heures = sorted(h for h in map(heure_image, chemins) if h)
|
|
print(f"Images : {len(chemins)}" + (f", du {iso(heures[0])} au {iso(heures[-1])}" if heures else ""))
|
|
inconnues = [p for p in chemins if heure_image(p) is None]
|
|
if inconnues:
|
|
print(f" noms sans heure reconnue : {len(inconnues)}")
|
|
if heures:
|
|
manquantes = []
|
|
for a, b in zip(heures, heures[1:]):
|
|
h = a + timedelta(hours=1)
|
|
while h < b:
|
|
manquantes.append(iso(h))
|
|
h += timedelta(hours=1)
|
|
print(f" heures pleines sans image entre la première et la dernière : {', '.join(manquantes) or 'aucune'}")
|
|
|
|
|
|
def mesures(par):
|
|
if not par:
|
|
print("\nAucune mesure : pas d'export « advanced » dans ce dossier.")
|
|
return
|
|
instants = sorted({m["t"] for ms in par.values() for m in ms})
|
|
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
|
|
print(f"\nPériode des mesures : {iso(instants[0])} → {iso(instants[-1])}, {len(instants)} instants")
|
|
print(f"Cadence (pas médian) : {cadence.total_seconds() / 60:.0f} min")
|
|
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(instants, instants[1:])]
|
|
trous = [x for x in trous if x[2] > 0]
|
|
print(f"Mesures manquantes (instants absents de la cadence) : {sum(n for *_, n in trous)}")
|
|
for a, b, n in trous:
|
|
print(f" entre {iso(a)} et {iso(b)} : {n}")
|
|
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
|
refs = [s for s in noms if est_reference(par[s])]
|
|
print(f"\nCapteurs : {len(par)} ({len(refs)} références, {len(par) - len(refs)} cibles)")
|
|
print(f"{'capteur':10} {'type':10} {'motif':11} {'seuil':>5} {'mesures':>7} {'rejetées':>8}")
|
|
for s in noms:
|
|
ms = par[s]
|
|
seuil = "/".join(f"{x:g}" for x in sorted({m['error_threshold'] for m in ms}))
|
|
print(f"{s:10} {'référence' if est_reference(ms) else 'cible':10} {ms[0]['pattern_type']:11} "
|
|
f"{seuil:>5} {len(ms):7} {sum(map(rejetee, ms)):8}")
|
|
|
|
|
|
def camera(dossier, par, debut=None, fin=None):
|
|
"""Poses de la caméra, et les instants de mesure sans pose (la caméra n'a pas été recalée)."""
|
|
poses = filtrer(charger_camera(dossier), debut, fin)
|
|
instants = sorted({m["t"] for ms in par.values() for m in filtrer(ms, debut, fin)})
|
|
quoi = "dans la fenêtre" if debut or fin else "sur toute la période"
|
|
if not poses:
|
|
print(f"\nPose de la caméra {quoi} : aucune")
|
|
return
|
|
avec = {p["t"].replace(second=0, microsecond=0) for p in poses}
|
|
print(f"\nPose de la caméra {quoi} : {len(poses)} recalages, {iso(poses[0]['t'])} → {iso(poses[-1]['t'])}")
|
|
suites = [] # [début, fin, nombre, rang] des instants de mesure consécutifs sans pose
|
|
for i, t in enumerate(instants):
|
|
if t.replace(second=0, microsecond=0) in avec:
|
|
continue
|
|
if suites and suites[-1][3] == i - 1:
|
|
suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i
|
|
else:
|
|
suites.append([t, t, 1, i])
|
|
print(f"Instants de mesure sans pose (pas de recalage) : {sum(x[2] for x in suites)} sur {len(instants)}")
|
|
if debut or fin:
|
|
for a, b, n, _ in suites:
|
|
print(f" {iso(a)}" + ("" if n == 1 else f" → {iso(b)} ({n})"))
|
|
|
|
|
|
def fenetre(par, debut, fin):
|
|
"""Pas absents et rejets datés sur la fenêtre debut/fin."""
|
|
instants = sorted({m["t"] for ms in par.values() for m in ms})
|
|
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
|
|
series = {s: {m["t"]: m for m in filtrer(ms, debut, fin)} for s, ms in par.items()}
|
|
dans = sorted({t for d in series.values() for t in d})
|
|
print(f"\nFenêtre {iso(dans[0])} → {iso(dans[-1])} : {len(dans)} instants présents")
|
|
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
|
print(f"Pas absents pour tous les capteurs, entre deux instants présents (cadence de {cadence.total_seconds() / 60:.0f} min) :")
|
|
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(dans, dans[1:])]
|
|
trous = [x for x in trous if x[2] > 0]
|
|
for a, b, n in trous:
|
|
print(f" entre {iso(a)} et {iso(b)} : {n}")
|
|
if not trous:
|
|
print(" (aucun)")
|
|
print("Instants présents où des capteurs n'ont pas de mesure :")
|
|
partiels = [(t, [s for s in noms if t not in series[s]]) for t in dans]
|
|
for t, manque in partiels:
|
|
if manque:
|
|
print(f" {iso(t)} : {len(manque)} capteurs : {','.join(manque)}")
|
|
if not any(m for _, m in partiels):
|
|
print(" (aucun)")
|
|
print("Mesures rejetées dans la fenêtre, par capteur (début → fin de chaque suite de pas consécutifs, nombre) :")
|
|
for s in noms:
|
|
rej = [t for t in sorted(series[s]) if rejetee(series[s][t])]
|
|
suites = []
|
|
for t in rej:
|
|
if suites and t - suites[-1][1] <= cadence * 1.5:
|
|
suites[-1][1], suites[-1][2] = t, suites[-1][2] + 1
|
|
else:
|
|
suites.append([t, t, 1])
|
|
if rej:
|
|
print(f" {s} ({len(rej)}) : " + "; ".join(iso(a) if a == b else f"{iso(a)} → {iso(b)} ({n})" for a, b, n in suites))
|
|
if not any(rejetee(m) for d in series.values() for m in d.values()):
|
|
print(" (aucune)")
|
|
refs = [s for s in noms if est_reference(par[s])]
|
|
if not any(m["inlier"] is not None for s in refs for m in series[s].values()):
|
|
print("Références retenues par la compensation : colonne inlier absente ou vide.")
|
|
return
|
|
def marque(s, t):
|
|
m = series[s].get(t)
|
|
return "absente" if m is None else "r" if rejetee(m) else "0" if m["inlier"] == 0 else "vide"
|
|
hors = [(t, tuple((s, marque(s, t)) for s in refs if t not in series[s] or series[s][t]["inlier"] != 1)) for t in dans]
|
|
compte = collections.Counter(len(refs) - len(h) for _, h in hors)
|
|
print(f"Références retenues par la compensation (inlier = 1) sur {len(refs)}, nombre d'instants : "
|
|
+ ", ".join(f"{k} : {compte[k]}" for k in sorted(compte, reverse=True)))
|
|
print("Instants où des références ne sont pas retenues (suites de pas consécutifs avec les mêmes références hors ; "
|
|
"r = rejetée, 0 = inlier 0, vide = inlier vide) :")
|
|
suites = []
|
|
for i, (t, h) in enumerate(hors):
|
|
if h and suites and suites[-1][3] == h and suites[-1][4] == i - 1:
|
|
suites[-1][1], suites[-1][2], suites[-1][4] = t, suites[-1][2] + 1, i
|
|
elif h:
|
|
suites.append([t, t, 1, h, i])
|
|
for a, b, n, h, _ in suites:
|
|
print(f" {iso(a) if n == 1 else f'{iso(a)} → {iso(b)} ({n})'} : {len(refs) - len(h)} retenues ; hors : "
|
|
+ ", ".join(f"{s} ({q})" for s, q in h))
|
|
if not suites:
|
|
print(" (aucun)")
|
|
|
|
|
|
def main(dossier, debut=None, fin=None, tout=False):
|
|
print(f"Dossier : {dossier}")
|
|
f = trouver(dossier)
|
|
fichiers(f, tout)
|
|
contenu(dossier, f, debut, fin)
|
|
images(f["images"])
|
|
par = charger(dossier)
|
|
mesures(par)
|
|
if par:
|
|
camera(dossier, par)
|
|
if par and (debut or fin):
|
|
fenetre(par, debut, fin)
|
|
camera(dossier, par, debut, fin)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
a.add_argument("dossier")
|
|
a.add_argument("--debut", type=instant)
|
|
a.add_argument("--fin", type=instant)
|
|
a.add_argument("--fichiers", action="store_true", help="liste complète des fichiers (sinon : le premier et le dernier au-delà de 5)")
|
|
o = a.parse_args()
|
|
main(o.dossier, o.debut, o.fin, o.fichiers)
|