commit 690400de0b25171e6c4c2a907e4ee68aca2db40a Author: maxime Date: Fri Nov 13 16:25:17 2026 +0100 Les données et leur pompage, extraits de Diagnostic-App (462ba9e) Co-Authored-By: Claude Opus 5.5 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..143452b --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +data/ +out/ +.env +__pycache__/ diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..a473908 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,36 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "pomper", + "detail": "Met à jour les stations suivies (extraction/stations.txt), images comprises ; extraction/README.md", + "type": "shell", + "command": "extraction/pomper.sh", + "problemMatcher": [] + }, + { + "label": "pomper une plage", + "detail": "Pompe une plage de jours UTC (--au exclu) pour une ou plusieurs stations, images comprises", + "type": "shell", + "command": "extraction/pomper.sh --du ${input:du} --au ${input:au} --images --delai 300 ${input:stations}", + "problemMatcher": [] + } + ], + "inputs": [ + { + "id": "du", + "type": "promptString", + "description": "Premier jour UTC (AAAA-MM-JJ) ; 3 jours avant la période voulue, pour l'historique des détecteurs" + }, + { + "id": "au", + "type": "promptString", + "description": "Dernier jour UTC, exclu (AAAA-MM-JJ)" + }, + { + "id": "stations", + "type": "promptString", + "description": "Numéros de série des stations, séparés par des espaces (ex. NORDEND)" + } + ] +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..25bca79 --- /dev/null +++ b/README.md @@ -0,0 +1,13 @@ +# aimsight-data + +Les données des stations AIMsight, en un seul exemplaire sur le poste, et leur pompage. + +- `data//` : rempli par le pompage, **hors de git** (`metrics/`, `displacement/`, `camera/`, `images/`…). Un dossier perdu se repompe. +- `extraction/` : le pompage, en lecture seule sur la plateforme ; mode d'emploi `extraction/README.md`. Tâches VS Code « pomper » et « pomper une plage ». +- `.env` : les identifiants de la base et de S3, à la racine, jamais versionné. + +Les autres dépôts (Diagnostic-App, Optimizer) lisent les données par un lien `data -> ~/aimsight-data/data`, ignoré par git. On ne pompe que d'ici : le verrou `out/pompage.lock` vaut pour ce seul dossier. + +Les étiquettes sont dans le dépôt voisin `~/labeling`. + +Extrait de Diagnostic-App le 2026-11-13 (commit 462ba9e) ; l'historique antérieur du pompage est dans Support-Agent. diff --git a/extraction/README.md b/extraction/README.md new file mode 100644 index 0000000..76ecc0e --- /dev/null +++ b/extraction/README.md @@ -0,0 +1,51 @@ +# extraction/ : pomper les données de la plateforme (lecture seule) + +`pomper.py` récupère, pour chaque station (numéro de série du système) et chaque jour UTC demandé, dans `data//` : +- les **métriques système** (énergie, disque, 4G, températures…), moyennes horaires, un CSV par métrique et par jour dans `metrics/` ; +- les **déplacements** (export « advanced »), un CSV par jour dans `displacement/` ; +- les **mouvements de la caméra** (`pan`, `tilt`, `scale`, `rotation`, `sigma0`), en médiane et bornes (`median_`, `min_`, `max_`) par minute, aux seuls instants où la caméra a été recalée, un CSV par jour dans `camera/` ; +- les **images** IRON (`--images`, une par heure par défaut, `--every 10` ou `--every 0` pour plus) dans `images/`, et différentielles (`--diff`) dans `images_diff/`. + +Formats : `~/labeling/connaissances/colonnes-des-deplacements.md`. + +**Stations suivies** : `stations.txt`, un numéro de série par ligne. Sans station ni dates, le script les met toutes à jour jusqu'à maintenant : chaque station comble d'abord ses jours manquants entre le premier et le dernier jour pompé (sans déplacements, ou sans aucune métrique), puis repart de son dernier jour, repompé (il était peut-être incomplet) ; une station sans dossier dans `data/` reçoit les 30 derniers jours. + +Reprise : avec `--du`, un fichier déjà dans `data//` n'est pas redemandé ; relancer sur une plage plus large ne lit que les jours et les images qui manquent. Le jour en cours est pompé tel qu'il est, ses métriques jusqu'à la dernière heure terminée ; le lancement suivant sans `--du` le remplace. + +## Lancer (sous WSL) + +`pomper.sh` lit les identifiants dans le `.env` à la racine du dépôt (base PostgreSQL et S3 ; jamais versionné, interdit en lecture à Claude), installe les 4 paquets nécessaires (`sqlalchemy`, `psycopg2-binary`, `pandas`, `boto3`) dans un environnement `uv` jetable (Python 3.12), lance `pomper.py`, puis `lenzspitze_absolu.py`. Sa sortie s'ajoute à `out/pompage.log` ; un second lancement pendant un pompage s'arrête aussitôt (verrou `out/pompage.lock`). Le verrou ne vaut que pour ce dossier : les autres dépôts lisent `data/` par un lien, ils ne pompent pas. + +Variables du `.env` : `AIMSIGHT_DATABASE_USER`, `_PSWD`, `_TURL`, `_NAME`, `_PORT` ; pour les images, `AIMSIGHT_S3_URL`, `_ACCESS_KEY`, `_SECRET_KEY`, `_BUCKET`. + +1. **Un essai** (1 station, 2 jours, dans un dossier jetable) : `extraction/pomper.sh --du 2026-11-09 --au 2026-11-11 --images --out /tmp/essai-pompage NORDEND` (6 s le 2026-11-12). `lenzspitze_absolu.py` convertit ensuite `data/LENZSPITZE`, pas le dossier `--out` : sans effet si `data/LENZSPITZE` est déjà converti. +2. **Mettre à jour les stations suivies** : `extraction/pomper.sh` (sans argument : `--images --delai 300`), ou la tâche VS Code **pomper**. Le script dit, pour chaque station, la plage qu'il pompe. +3. **Une plage choisie** (historique, jour en échec), avec 3 jours de plus avant (l'historique des détecteurs) : `extraction/pomper.sh --du 2026-10-02 --au 2026-10-26 --images ` (`--au` exclu ; plusieurs stations : ` `). Aide : `extraction/pomper.sh -h`. + +**Chaque nuit, automatiquement** : une tâche du Planificateur de tâches de Windows, à créer une fois dans PowerShell (pas en administrateur). Elle démarre WSL au besoin et, PC éteint ou en veille à l'heure dite, part dès qu'il se rallume ; un jour manqué est rattrapé au lancement suivant. + +```powershell +$a = New-ScheduledTaskAction -Execute "wsl.exe" -Argument "-d Ubuntu -e bash -lc /home/maxime/aimsight-data/extraction/pomper.sh" +$t = New-ScheduledTaskTrigger -Daily -At 04:00 +$s = New-ScheduledTaskSettingsSet -StartWhenAvailable -ExecutionTimeLimit (New-TimeSpan -Hours 6) +Register-ScheduledTask -TaskName "AIMsight pompage" -Action $a -Trigger $t -Settings $s +``` + +Essayer la tâche tout de suite : `Start-ScheduledTask "AIMsight pompage"`, puis lire `out/pompage.log`. La retirer : `Unregister-ScheduledTask "AIMsight pompage"`. + +Lecture seule : moteur dédié, `default_transaction_read_only`, délai de 60 s par requête, une requête par jour ; hors des heures chargées (base partagée avec la production). + +Sans dépendance à l'appli `monitoring-dashboard` : ses lectures sont recopiées dans `pomper.py`, en SQL (sa docstring dit lesquelles, et de quel commit). Si l'appli change ses lectures, le script ne suit pas : comparer à nouveau des fichiers pompés aux deux. + +## Avec Claude + +Claude peut lancer `pomper.sh` lui-même (accord de l'utilisateur, 2026-11-12) : lecture seule, petites plages ; une longue plage ou un historique, hors des heures chargées. Il ne lit jamais le `.env`. + +## À savoir + +- `` est le numéro de série du **système**, celui de l'URL de la page System (`/explore/system/`) et du début des CSV qu'on y télécharge (`NORDEND_BusVoltage_…` : `NORDEND`) ; pas le nom de l'appareil de la page Explore. +- `data/` est hors de git : un dossier perdu se repompe. +- Un jour en échec par délai dépassé (`QueryCanceled: … statement timeout`) : le relancer seul avec `--delai 300`. La lenteur vient de la base, pas du volume. +- Une heure sans image peut avoir sa mesure : l'image n'est jamais arrivée sur S3 (`measurement_uuid` vide, envoi inachevé). Le script la saute et prend l'image suivante de la tranche s'il y en a une. +- Un jour passé, pompé avant que la station ait fini d'envoyer ses données (coupure, synchronisation en retard), reste incomplet : supprimer ses fichiers dans `data//` et relancer. +- LENZSPITZE : ses exports ont `x` / `y` relatifs et `pattern_type` vide ; `pomper.sh` lance ensuite `lenzspitze_absolu.py` (provisoire ; détail dans `~/labeling/connaissances/colonnes-des-deplacements.md`). diff --git a/extraction/lenzspitze_absolu.py b/extraction/lenzspitze_absolu.py new file mode 100644 index 0000000..8a08275 --- /dev/null +++ b/extraction/lenzspitze_absolu.py @@ -0,0 +1,49 @@ +"""Provisoire, LENZSPITZE seulement : x / y des exports advanced en position absolue dans l'image, comme sur les autres stations. + +Sur LENZSPITZE, x / y sont relatifs à la position de référence du motif (médianes ~0 px). Ce script réécrit en place +data/LENZSPITZE/displacement/*.csv : + x = x_motif + DX + x_csv, y = y_motif + DY + y_csv, où (x_motif, y_motif) est le centre du motif dans + data/LENZSPITZE/lentzpitze_patterns.json et (DX, DY) le décalage entre le repère du JSON et les images IRON ; + pattern_type, vide dans ces exports, est rempli depuis le JSON. +Les capteurs absents du JSON (1023, 8019) : x / y vidés (position inconnue) ; 8019 reçoit global_ref (il a des reproj_err). +Un fichier dont pattern_type est déjà rempli est laissé tel quel (déjà converti). Un repompage rend les originaux. + +Usage : python3 extraction/lenzspitze_absolu.py +""" +import csv +import glob +import json +import os + +STATION = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "data", "LENZSPITZE") +# Mesuré le 2026-11-04 : médiane (tache − motif du JSON) sur 9 images de nuit du 17.10 au 03.11, 25 à 34 cibles appariées +# chacune, stable à 0,5 px près. Comprend l'écart constant tache − (x, y) déjà vu sur NORDEND (colonnes-des-deplacements.md). +DX, DY = 330.5, 15.8 +TYPE_SANS_MOTIF = {"8019": "global_ref"} # reproj_err et inlier remplis : référence de la compensation + +motifs = {str(v["sensor_name"]): v for v in json.load(open(os.path.join(STATION, "lentzpitze_patterns.json"))).values()} + +for chemin in sorted(glob.glob(os.path.join(STATION, "displacement", "*.csv"))): + with open(chemin, newline="") as f: + lecteur = csv.DictReader(f) + champs, lignes = lecteur.fieldnames, list(lecteur) + if any(r["pattern_type"] for r in lignes): + print(f"{os.path.basename(chemin)} : déjà converti") + continue + for r in lignes: + s = r["sensor_name"].strip() + m = motifs.get(s) + if m is None: + r["x"] = r["y"] = "" + r["pattern_type"] = TYPE_SANS_MOTIF.get(s, "") + continue + r["pattern_type"] = m["pattern_type"] + if r["x"]: + r["x"] = repr(m["x"] + DX + float(r["x"])) + if r["y"]: + r["y"] = repr(m["y"] + DY + float(r["y"])) + with open(chemin, "w", newline="") as f: + w = csv.DictWriter(f, fieldnames=champs) + w.writeheader() + w.writerows(lignes) + print(f"{os.path.basename(chemin)} : {len(lignes)} lignes converties") diff --git a/extraction/pomper.py b/extraction/pomper.py new file mode 100644 index 0000000..e06afc9 --- /dev/null +++ b/extraction/pomper.py @@ -0,0 +1,408 @@ +"""Pompe les métriques système, les déplacements (export « advanced ») et les images de stations de la plateforme +AIMsight, dans le format que lisent l'app, les outils de lecture et les détecteurs. LECTURE SEULE. Essayé le +2026-10-26 (NORDEND, 2 jours) ; autonome depuis le 2026-11-12. + +À lancer par extraction/pomper.sh, sous WSL, depuis n'importe où (voir README.md) : + + extraction/pomper.sh + extraction/pomper.sh --du 2026-08-01 --au 2026-08-08 --images WEISSHORN + +Sans station : celles de `stations.txt`. Sans `--du` : chaque station comble ses jours manquants (déplacements ou +métriques) avant le dernier pompé, puis repart de ce dernier jour, repompé (il était peut-être incomplet), ou des 30 +derniers jours si elle n'en a pas ; sans `--au` : jusqu'à maintenant. + +Sortie (défaut : le `data/` du dépôt, à côté de ce dossier) : + /metrics/___00_00 to _23_00.csv métriques système, par jour + /displacement/_advanced_.csv déplacements, un fichier par jour + /camera/_camera_.csv mouvements de la caméra, par jour + /images/TZ_. images OPTICAL_SHIFT-IRON (--images) + /images_diff/… images différentielles (--diff) +Reprenable : avec `--du`, un fichier déjà écrit n'est pas relu, quelles que soient les dates demandées ; sans `--du`, +les jours de la plage sont remplacés (images exceptées). Jours en UTC, `--au` exclu ; le jour en cours est pompé tel +qu'il est, ses métriques jusqu'à la dernière heure terminée. Pour reprendre un jour, supprimer ses fichiers. + +Sans dépendance à l'appli (~/monitoring-dashboard) : ses lectures sont recopiées ici, en SQL, telles quelles (branche +`explo`, commit 3dce73d du 2026-11-12) : la requête de System.get_metrics (le téléchargement de la page System) ; +build_advanced_frame (app/datapoints.py, ce que tracent l'onglet Advanced et l'export parquet), avec +AcquisitionUnit.get_datapoints et AggregateEngine.get_sensor_aggregate / get_common_aggregate ; les mouvements de la +caméra de fetch_cam_movements_frame (AggregateEngine.get_cam_scalar_aggregate, ce que trace le visualiseur) ; +AcquisitionUnit.measurements et get_measurement_payload (S3). Si l'appli change ses lectures, ce fichier ne suit pas. +Connexion en lecture seule (`default_transaction_read_only`), délai de 60 s par requête (`--delai`). Variables lues +(noms seulement, aucune n'est affichée) : AIMSIGHT_DATABASE_USER / _PSWD / _TURL / _NAME / _PORT, et pour les images +AIMSIGHT_S3_URL / _ACCESS_KEY / _SECRET_KEY / _BUCKET. +""" +import argparse +import os +import sys +import time +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import pandas as pd +from sqlalchemy import create_engine, text +from sqlalchemy.engine import URL + +UTC = timezone.utc +STATIONS = Path(__file__).resolve().parent / "stations.txt" # les stations suivies, une par ligne +JOURS_NOUVELLE = 30 # sans --du, une station sans déplacements pompés : les 30 derniers jours +DB_NAMES = ["AIMSIGHT_DATABASE_USER", "AIMSIGHT_DATABASE_PSWD", "AIMSIGHT_DATABASE_TURL", "AIMSIGHT_DATABASE_NAME"] +TYPES = {"images": "OPTICAL_SHIFT-IRON", "images_diff": "OPTICAL_SHIFT-DIFF"} # dossier -> type de mesure + +# --- constantes de l'appli (app/datapoints.py, app/aggregates.py) --- +QUALITY = ["peak", "flux", "sharpness", "fwhm", "dominance", "snr"] +CAM_SIGNALS = ["pan", "tilt", "scale", "rotation", "sigma0"] +DEFAULT_ERROR_THRESHOLD = 0.7 +DATATYPES = ["x", "y", "error", "corr_x", "corr_y", "reproj_err", "inlier", "sigma0"] +PROPERTIES = ["x", "y", "pattern_type", "sensor_name", "error_threshold"] +COLUMNS = ["time_utc", "sensor_name", "x", "y", "error_value", "error_threshold", "relative_x", "relative_y", "corr_x", + "corr_y", "reproj_err", "inlier", "sigma0", "pattern_type"] + QUALITY +NUMERIC = ["x", "y", "error_value", "error_threshold", "relative_x", "relative_y", "corr_x", "corr_y", "reproj_err", + "inlier", "sigma0"] + QUALITY +# bandes d'inlier de shift_sensor_1min -> code ; les deux derniers NOMS sont faux (-1 rejeté, -2 interpolé), les codes +# sont justes ; ordre du meilleur au pire +INLIER_BANDS = {"inlier_in_fit": 1.0, "inlier_out_fit": 0.0, "inlier_no_redundancy": -1.0, "inlier_rejected": -2.0} + + +def raison(e): + """L'erreur d'origine (celle de la base) : pandas et SQLAlchemy l'enveloppent, la requête SQL d'abord.""" + while e.__cause__ is not None: + e = e.__cause__ + return f"{type(e).__name__}: {(str(e).splitlines() or [''])[0][:300]}" + + +def lire(conn, sql, **params): + return pd.read_sql(text(sql), conn, params=params) + + +def acquisition_unit(conn, system_id): + """Même choix que Device.get_acquisition_unit (app/base/models.py:268) : l'unique unité, sinon MER* / ME2S*.""" + units = conn.execute(text("SELECT id, product_number FROM acquisition_unit WHERE system_id = :s"), + {"s": system_id}).all() + pick = units if len(units) == 1 else [u for u in units if u.product_number.startswith(("MER", "ME2S"))] + return pick[0].id if pick else None + + +def plages_suivi(dossier, fin, demain): + """Sans --du : (début, fin, remplacer) à pomper, d'après les jours de déplacements déjà pompés. Les jours manquants + entre le premier et le dernier (plages pompées à part, jour en échec) sont comblés sans toucher aux autres ; le + dernier jour est repompé (pompé en cours de journée, il était incomplet) jusqu'à maintenant ; une station sans + déplacements pompés reçoit les 30 derniers jours.""" + jours = {datetime.strptime(p.stem.rsplit("_", 1)[1], "%Y%m%d").date() + for p in (dossier / "displacement").glob(f"{dossier.name}_advanced_*.csv")} + if not jours: + return [(demain - timedelta(days=JOURS_NOUVELLE + 1), fin, True)] + # un jour de métriques en échec n'a aucun fichier (une requête pour toutes) : c'est aussi un trou ; une station + # sans aucune métrique n'en a jamais, ses jours n'en sont pas + metriques = {datetime.strptime(p.name.split(" to ")[0][-16:-6], "%Y_%m_%d").date() + for p in (dossier / "metrics").glob(f"{dossier.name}_*_00_00 to *.csv")} + premier, dernier = min(jours), max(jours) + trous = [premier + timedelta(days=k) for k in range((dernier - premier).days) + if premier + timedelta(days=k) not in jours or (metriques and premier + timedelta(days=k) not in metriques)] + return ([(trous[0], dernier, False)] if trous else []) + [(dernier, fin, True)] + + +def pomper_metriques(conn, system_id, station, debut, fin, out, remplacer): + """Comme le téléchargement de la page System (Dashboard/System.py, get_metrics(..., bucketing="1 hour")) : par + heure, moyenne * transform_factor + transform_offset, ou la liste des valeurs d'une métrique texte ; les séries à + labels d'une même métrique confondues ; une ligne vide pour une heure sans mesure. get_metrics compte en heures + avant maintenant : sa requête est refaite ici sur un jour fixe, une requête par jour pour toutes les métriques.""" + noms = sorted(conn.execute(text("SELECT DISTINCT dt.name FROM datatype dt JOIN metric_series se " + "ON se.datatype_id = dt.id WHERE se.system_id = :s"), {"s": system_id}).scalars()) + conn.rollback() + for k in range((fin - debut).days): + a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) + paths = {n: out / station / "metrics" + / f"{station}_{n.replace(os.sep, '-')}_{a:%Y_%m_%d}_00_00 to {a:%Y_%m_%d}_23_00.csv" for n in noms} + if not remplacer and all(p.exists() for p in paths.values()): + continue + t0 = time.time() + try: + # date_trunc('hour') : même découpage que time_bucket('1 hour') + df = lire(conn, """ + SELECT date_trunc('hour', ms.time_utc) AS heure, dt.name AS nom, + avg(ms.value_num) * any_value(dt.transform_factor) + any_value(dt.transform_offset) AS num, + jsonb_agg(ms.value_text) FILTER (WHERE ms.value_text IS NOT NULL) AS txt + FROM metric_sample ms + JOIN metric_series se ON ms.series_id = se.id + JOIN datatype dt ON se.datatype_id = dt.id + WHERE se.system_id = :s AND ms.time_utc >= :a AND ms.time_utc < :b + GROUP BY 1, dt.name""", s=system_id, a=a, b=a + timedelta(days=1)) + except Exception as e: # ponytail : comme les déplacements, un jour en échec est sauté, relancer le reprend + print(f"{station} {a:%Y-%m-%d} métriques : échec ({raison(e)}), à relancer") + continue + finally: + conn.rollback() + df["heure"] = pd.to_datetime(df["heure"], utc=True) + heures = pd.to_datetime(pd.date_range(a, periods=24, freq="h"), utc=True) # même fuseau que df, pour reindex + # jour en cours : les heures terminées seulement, sinon les heures à venir seraient lues comme un trou + heures = heures[heures + pd.Timedelta(hours=1) <= pd.Timestamp.now(tz=UTC)] + for n, path in paths.items(): + d = df[df["nom"] == n].set_index("heure") + col = d["num"] if d["num"].notna().any() else d["txt"] # métrique texte : la liste de l'heure + path.parent.mkdir(parents=True, exist_ok=True) + # CSV de la page System : ',time_utc,metric', l'index en première colonne ; un jour vide est écrit aussi + pd.DataFrame({"time_utc": heures, "metric": col.reindex(heures).to_numpy()}).to_csv(path) + print(f"{station} {a:%Y-%m-%d} métriques : {len(noms)} fichiers, {df['nom'].nunique()} avec mesure, " + f"{time.time() - t0:.0f} s") + + +# --- l'export « advanced » : build_advanced_frame (app/datapoints.py) --- + +def datapoints_bruts(conn, unit, a, b): + """AcquisitionUnit.get_datapoints : les datapoints de l'unité, un type par colonne, les propriétés des capteurs + à côté (prop_x / prop_y : la position de référence, homonyme d'un type).""" + types = ",\n".join(f"max(d.value) FILTER (WHERE dt.name = '{t}') AS {t}" for t in DATATYPES) + noms = {p: f"prop_{p}" if p in DATATYPES else p for p in PROPERTIES} + props = ",\n".join(f"any_value(p_{p}.value) AS {noms[p]}" for p in PROPERTIES) + joints = "\n".join(f"LEFT JOIN (SELECT p.sensor_id, p.value FROM property p JOIN datatype pdt " + f"ON p.datatype_id = pdt.id WHERE pdt.name = '{p}') p_{p} ON d.sensor_id = p_{p}.sensor_id" + for p in PROPERTIES) + return lire(conn, f""" + SELECT d.time_utc, d.sensor_id, any_value(d.measurement_id) AS measurement_id, + {types}, + {props} + FROM datapoint d + JOIN sensor s ON d.sensor_id = s.id + JOIN datatype dt ON d.datatype_id = dt.id + {joints} + WHERE s.acquisition_unit_id = :au AND d.time_utc >= :a AND d.time_utc <= :b + GROUP BY d.time_utc, d.sensor_id + ORDER BY d.sensor_id, d.time_utc""", au=unit, a=a, b=b) + + +def preparer_bruts(shifts): + """prepare_datapoints_frame : sigma0 (lignes de la caméra, sans sensor_name) recopié sur chaque capteur à son + instant ; relative = x - prop_x ; error -> error_value ; le schéma complet.""" + if shifts.empty: + return pd.DataFrame(columns=COLUMNS) + sig = shifts.loc[shifts["sigma0"].notna(), ["time_utc", "sigma0"]] + sigma0 = sig.groupby("time_utc")["sigma0"].median() if not sig.empty else None + shifts = shifts.dropna(subset=["sensor_name"]).reset_index(drop=True) + shifts["sigma0"] = shifts["time_utc"].map(sigma0) if sigma0 is not None else pd.NA + shifts["relative_x"] = shifts["x"] - pd.to_numeric(shifts["prop_x"], errors="coerce") + shifts["relative_y"] = shifts["y"] - pd.to_numeric(shifts["prop_y"], errors="coerce") + shifts = shifts.drop(columns=["prop_x", "prop_y"]).rename(columns={"error": "error_value"}) + shifts["time_utc"] = pd.to_datetime(shifts["time_utc"]) + shifts["sensor_name"] = shifts["sensor_name"].astype(str) + for c in NUMERIC: + if c in shifts: + shifts[c] = pd.to_numeric(shifts[c], errors="coerce") + return shifts.reindex(columns=COLUMNS) + + +def etats_agreges(conn, unit, a, b): + """fetch_aggregate_datapoints_frame : les médianes par minute des tables d'états (shift_sensor_1min, + shift_common_1min), seule source des appareils « burst », au schéma de l'export (prepare_aggregate_datapoints_frame). + Dans les états, x_pct porte le x CORRIGÉ et rx_pct le x brut.""" + thr = "COALESCE((th.value #>> '{}')::double precision, CAST(:thr AS double precision))" + sensor = lire(conn, f""" + SELECT ss.time_utc, COALESCE(sn.value #>> '{{}}', s.name) AS name, + approx_percentile(0.5, ss.x_pct) AS corr_x, approx_percentile(0.5, ss.y_pct) AS corr_y, + approx_percentile(0.5, ss.rx_pct) AS x, approx_percentile(0.5, ss.ry_pct) AS y, + approx_percentile(0.5, ss.error_pct) AS error, {thr} AS error_threshold, + approx_percentile(0.5, ss.reproj_err_pct) AS reproj_err, + {", ".join(f"ss.{n}" for n in INLIER_BANDS)}, + {", ".join(f"approx_percentile(0.5, ss.{m}_pct) AS {m}" for m in QUALITY)} + FROM shift_sensor_1min ss + JOIN sensor s ON s.id = ss.sensor_id + LEFT JOIN (SELECT p.sensor_id, any_value(p.value) AS value FROM property p JOIN datatype dt + ON dt.id = p.datatype_id WHERE dt.name = 'sensor_name' GROUP BY p.sensor_id) sn + ON sn.sensor_id = ss.sensor_id + LEFT JOIN (SELECT p.sensor_id, any_value(p.value) AS value FROM property p JOIN datatype dt + ON dt.id = p.datatype_id WHERE dt.name = 'error_threshold' GROUP BY p.sensor_id) th + ON th.sensor_id = ss.sensor_id + WHERE s.acquisition_unit_id = :au AND ss.time_utc >= :a AND ss.time_utc <= :b + ORDER BY ss.time_utc""", au=unit, a=a, b=b, thr=DEFAULT_ERROR_THRESHOLD) + if sensor.empty: + return pd.DataFrame(columns=COLUMNS) + common = lire(conn, """ + SELECT sc.time_utc, approx_percentile(0.5, sc.sigma0_pct) AS sigma0 FROM shift_common_1min sc + WHERE sc.acquisition_unit_id = :au AND sc.time_utc >= :a AND sc.time_utc <= :b""", au=unit, a=a, b=b) + out = pd.DataFrame({"time_utc": pd.to_datetime(sensor["time_utc"]), "sensor_name": sensor["name"].astype(str)}) + for col, src in [("error_value", "error"), ("error_threshold", "error_threshold"), ("corr_x", "corr_x"), + ("corr_y", "corr_y"), ("relative_x", "corr_x"), ("relative_y", "corr_y"), ("x", "x"), ("y", "y"), + ("reproj_err", "reproj_err")] + [(m, m) for m in QUALITY]: + out[col] = pd.to_numeric(sensor[src], errors="coerce") + # inlier_code_from_bands : la bande majoritaire, l'égalité à la pire ; toutes à 0 -> NaN (pas de redondance) + counts = sensor[list(INLIER_BANDS)].apply(pd.to_numeric, errors="coerce").fillna(0) + code = counts[list(INLIER_BANDS)[::-1]].idxmax(axis=1).map(INLIER_BANDS) + out["inlier"] = code.where(counts.sum(axis=1) > 0).to_numpy() + out["pattern_type"] = None + sig = common.loc[common["sigma0"].notna()] + out["sigma0"] = (out["time_utc"].map(sig.assign(time_utc=pd.to_datetime(sig["time_utc"])) + .groupby("time_utc")["sigma0"].median()) if not sig.empty else float("nan")) + return out.reindex(columns=COLUMNS) + + +def fusionner(raw, agg): + """merge_raw_and_aggregate_frames : le brut gagne ; un état n'est gardé que là où son capteur n'a pas de ligne + brute dans la même minute.""" + if agg.empty: + return raw + if raw.empty: + return agg + + def utc(t): + t = pd.to_datetime(t) + return t.dt.tz_localize("UTC") if t.dt.tz is None else t.dt.tz_convert("UTC") + + cles = pd.MultiIndex.from_arrays([raw["sensor_name"], utc(raw["time_utc"]).dt.floor("1min")]) + agg = agg.loc[~pd.MultiIndex.from_arrays([agg["sensor_name"], utc(agg["time_utc"]).dt.floor("1min")]).isin(cles)] + if agg.empty: + return raw + agg = agg.copy() + tz = pd.to_datetime(raw["time_utc"]).dt.tz + t = utc(agg["time_utc"]) + agg["time_utc"] = t.dt.tz_convert(tz) if tz is not None else t.dt.tz_localize(None) + return (pd.concat([raw, agg], ignore_index=True).sort_values(["sensor_name", "time_utc"], kind="stable") + .reset_index(drop=True).reindex(columns=COLUMNS)) + + +def advanced(conn, unit, a, b): + return fusionner(preparer_bruts(datapoints_bruts(conn, unit, a, b)), etats_agreges(conn, unit, a, b)) + + +def camera(conn, unit, a, b): + """Pan, tilt, scale, rotation et sigma0 de la caméra, en médiane et bornes (median_ / min_ / max_) par minute, donc + une ligne par mesure de la caméra (toutes les 15 min à NORDEND, min = max) : ce que trace le visualiseur + (fetch_cam_movements_frame), sans son except, qui rendrait vide un jour en échec au lieu de le laisser à relancer.""" + sigs = ", ".join(f"approx_percentile(0.5, sc.{s}_pct) AS median_{s}, min_val(sc.{s}_pct) AS min_{s}, " + f"max_val(sc.{s}_pct) AS max_{s}" for s in CAM_SIGNALS) + return lire(conn, f"""SELECT sc.time_utc, {sigs} FROM shift_common_1min sc + WHERE sc.acquisition_unit_id = :au AND sc.time_utc >= :a AND sc.time_utc <= :b + ORDER BY sc.time_utc""", au=unit, a=a, b=b) + + +JOURS = (("displacement", "advanced", advanced), ("camera", "camera", camera)) # dossier, fichier, lecture + + +def pomper_deplacements(conn, unit, station, debut, fin, out, remplacer): + """Déplacements et mouvements de la caméra : un fichier et une requête par jour, bornée, sous le délai (--delai).""" + for k in range((fin - debut).days): + a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) + for dossier, nom, lecture in JOURS: + path = out / station / dossier / f"{station}_{nom}_{a:%Y%m%d}.csv" + if path.exists() and not remplacer: + continue + t0 = time.time() + try: + df = lecture(conn, unit, a, a + timedelta(days=1) - timedelta(microseconds=1)) + except Exception as e: # ponytail : un jour en échec est sauté, relancer le reprend ; pas de nouvel essai + print(f"{station} {a:%Y-%m-%d} {nom} : échec ({raison(e)}), à relancer") + continue + finally: + conn.rollback() # ferme la transaction de lecture + if "sensor_name" in df: + df = df.drop_duplicates(["sensor_name", "time_utc"]) + path.parent.mkdir(parents=True, exist_ok=True) + df.to_csv(path, index=False) # un jour vide est écrit aussi : la relance ne le redemande pas + print(f"{station} {a:%Y-%m-%d} {nom}: {len(df)} lignes, {time.time() - t0:.0f} s -> {path.name}") + + +def pomper_images(conn, s3, unit, station, debut, fin, dossier, every, out): + mt = conn.execute(text("SELECT id, extension FROM measurement_type WHERE name = :n"), {"n": TYPES[dossier]}).first() + if mt is None: + print(f"{station} : type {TYPES[dossier]} inconnu") + return + client, bucket_s3 = s3 + for k in range((fin - debut).days): + a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) + mesures = conn.execute(text( + "SELECT id, time_utc, measurement_uuid FROM measurement WHERE acquisition_unit_id = :au " + "AND measurement_type_id = :mt AND time_utc >= :a AND time_utc < :b ORDER BY time_utc"), + {"au": unit, "mt": mt.id, "a": a, "b": a + timedelta(days=1)}).all() + conn.rollback() + seen, n, octets, sans_uuid, absentes = set(), 0, 0, 0, 0 + for m in mesures: + # measurement_uuid vide : l'image n'est jamais arrivée sur S3 (envoi en plusieurs parties inachevé) ; + # écartée, la tranche prend l'image suivante s'il y en a une + if m.measurement_uuid is None: + sans_uuid += 1 + continue + t = m.time_utc.astimezone(UTC) + bucket = (t.hour * 60 + t.minute) // every if every else m.id # une image par tranche de `every` min + path = out / station / dossier / f"{t:%Y%m%dT%H%M}Z_{m.id}.{mt.extension}" + if bucket in seen: + continue + seen.add(bucket) # même déjà là : sinon la relance prendrait l'image suivante de la tranche + if path.exists(): + continue + try: + data = client.get_object(Bucket=bucket_s3, Key=m.measurement_uuid)["Body"].read() + except Exception: # comme get_measurement_payload : S3 qui ne répond pas, l'image est comptée absente + data = None + if data: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(data) + n, octets = n + 1, octets + len(data) + else: + absentes += 1 + # le détail dit pourquoi un jour rend 0 : rien en base, jamais arrivées sur S3, ou S3 qui ne les rend pas + print(f"{station} {a:%Y-%m-%d} {dossier}: {n} nouvelles images, {octets / 1e6:.0f} Mo " + f"({len(mesures)} en base, {sans_uuid} jamais arrivées sur S3, {absentes} non rendues par S3)") + time.sleep(0.5) + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument("stations", nargs="*", help="numéro de série du système, comme dans l'URL de la page System ; " + "aucun : ceux de stations.txt") + p.add_argument("--du", help="premier jour UTC, AAAA-MM-JJ ; sans : le dernier jour pompé de chaque station, " + "repompé, ou les 30 derniers jours") + p.add_argument("--au", help="dernier jour UTC exclu, AAAA-MM-JJ ; sans : jusqu'à maintenant") + p.add_argument("--images", action="store_true", help="aussi les images OPTICAL_SHIFT-IRON") + p.add_argument("--diff", action="store_true", help="aussi les images OPTICAL_SHIFT-DIFF") + p.add_argument("--every", type=int, default=60, help="une image par tranche de N minutes, 0 = toutes (défaut 60)") + p.add_argument("--delai", type=int, default=60, help="délai maximal d'une requête, en s (défaut 60 : base partagée " + "avec la production) ; plus long seulement pour un jour en échec par délai dépassé") + p.add_argument("--out", type=Path, default=Path(__file__).resolve().parent.parent / "data") + a = p.parse_args() + demain = datetime.now(UTC).date() + timedelta(days=1) + du = datetime.strptime(a.du, "%Y-%m-%d").date() if a.du else None + fin = min(datetime.strptime(a.au, "%Y-%m-%d").date(), demain) if a.au else demain # pas de jour à venir + stations = a.stations or STATIONS.read_text().split() + + missing = [n for n in DB_NAMES if not os.environ.get(n)] + if missing: + sys.exit(f"Variables absentes (noms seulement) : {', '.join(missing)}") + url = URL.create("postgresql+psycopg2", username=os.environ["AIMSIGHT_DATABASE_USER"], + password=os.environ["AIMSIGHT_DATABASE_PSWD"], host=os.environ["AIMSIGHT_DATABASE_TURL"], + port=int(os.environ.get("AIMSIGHT_DATABASE_PORT", "5432")), + database=os.environ["AIMSIGHT_DATABASE_NAME"]) + engine = create_engine(url, connect_args={ + "options": f"-c timezone=utc -c default_transaction_read_only=on -c statement_timeout={a.delai}s"}) + s3 = None + if a.images or a.diff: + import boto3 # comme S3client de l'appli (Garage) + s3 = (boto3.client("s3", endpoint_url=os.environ.get("AIMSIGHT_S3_URL", "http://s3:3900"), + aws_access_key_id=os.environ.get("AIMSIGHT_S3_ACCESS_KEY", ""), + aws_secret_access_key=os.environ.get("AIMSIGHT_S3_SECRET_KEY", ""), + region_name="garage", use_ssl=False), + os.environ.get("AIMSIGHT_S3_BUCKET", "measurements-assets")) + try: + with engine.connect() as conn: + for station in stations: + system_id = conn.execute(text("SELECT id FROM system WHERE serial_number = :s"), {"s": station}).scalar() + if system_id is None: + print(f"{station} : système inconnu") + continue + plages = [(du, fin, False)] if du else plages_suivi(a.out / station, fin, demain) + unit = acquisition_unit(conn, system_id) + conn.rollback() + for debut, fin_plage, remplacer in plages: + print(f"{station} : du {debut} au {fin_plage - timedelta(days=1)} inclus" + + ("" if remplacer else ", jours manquants seulement")) + pomper_metriques(conn, system_id, station, debut, fin_plage, a.out, remplacer) + if unit is None: + print(f"{station} : pas d'unité d'acquisition reconnue, ni déplacements, ni caméra, ni images") + continue + pomper_deplacements(conn, unit, station, debut, fin_plage, a.out, remplacer) + for flag, dossier in ((a.images, "images"), (a.diff, "images_diff")): + if flag: + pomper_images(conn, s3, unit, station, debut, fin_plage, dossier, a.every, a.out) + finally: + engine.dispose() + + +if __name__ == "__main__": + main() diff --git a/extraction/pomper.sh b/extraction/pomper.sh new file mode 100755 index 0000000..ffeb15f --- /dev/null +++ b/extraction/pomper.sh @@ -0,0 +1,25 @@ +#!/usr/bin/env bash +# Pompage sous WSL. Lit les identifiants dans le .env à la racine du dépôt (jamais versionné), +# lance pomper.py dans un environnement uv jetable (4 paquets), puis le post-traitement de LENZSPITZE. +# extraction/pomper.sh mise à jour des stations suivies, images comprises (le planificateur) +# extraction/pomper.sh --du D --au F [SERIE] tout autre appel : les arguments vont tels quels à pomper.py +# Sortie ajoutée à out/pompage.log ; un seul pompage à la fois (verrou out/pompage.lock). +set -u +export PATH="$HOME/.local/bin:$PATH" # uv, absent du PATH quand le Planificateur de tâches lance wsl.exe +ici=$(cd "$(dirname "$0")" && pwd) +racine=$(dirname "$ici") +mkdir -p "$racine/out" + +exec 9>"$racine/out/pompage.lock" +flock -n 9 || { echo "Un pompage tourne déjà." >&2; exit 1; } + +[ $# -eq 0 ] && set -- --images --delai 300 +{ + echo "=== $(date -u +%Y-%m-%dT%H:%MZ) pomper.py $*" + (set -a && . "$racine/.env" && set +a && + uv run --no-project --quiet --python 3.12 \ + --with sqlalchemy --with psycopg2-binary --with pandas --with boto3 \ + python "$ici/pomper.py" "$@") + [ -f "$racine/data/LENZSPITZE/lentzpitze_patterns.json" ] && python3 "$ici/lenzspitze_absolu.py" + echo "=== $(date -u +%Y-%m-%dT%H:%MZ) fin" +} 2>&1 | tee -a "$racine/out/pompage.log" diff --git a/extraction/stations.txt b/extraction/stations.txt new file mode 100644 index 0000000..f4d2353 --- /dev/null +++ b/extraction/stations.txt @@ -0,0 +1,13 @@ +BREITHORN +CLARIDEN +FLORIDA +JUNGFRAU +LENZSPITZE +MICHIGAN +NADELHORN +NEBRASKA +NIEDERHORN +NORDEND +WILDSTRUBEL +SUSTENHORN +SNCF01 \ No newline at end of file