Les données et leur pompage, extraits de Diagnostic-App (462ba9e)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-13 16:25:17 +01:00
commit 690400de0b
8 files changed
+599

No files matched your search

+51
View File
@@ -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/<SERIE>/` :
- 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/<SERIE>/` 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 <SERIE>` (`--au` exclu ; plusieurs stations : `<SERIE1> <SERIE2>`). 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
- `<SERIE>` est le numéro de série du **système**, celui de l'URL de la page System (`/explore/system/<SERIE>`) 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/<SERIE>/` 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`).
+49
View File
@@ -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")
+408
View File
@@ -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) :
<STATION>/metrics/<STATION>_<métrique>_<AAAA_MM_JJ>_00_00 to <AAAA_MM_JJ>_23_00.csv métriques système, par jour
<STATION>/displacement/<STATION>_advanced_<AAAAMMJJ>.csv déplacements, un fichier par jour
<STATION>/camera/<STATION>_camera_<AAAAMMJJ>.csv mouvements de la caméra, par jour
<STATION>/images/<AAAAMMJJ>T<HHMM>Z_<id>.<ext> images OPTICAL_SHIFT-IRON (--images)
<STATION>/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()
+25
View File
@@ -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"
+13
View File
@@ -0,0 +1,13 @@
BREITHORN
CLARIDEN
FLORIDA
JUNGFRAU
LENZSPITZE
MICHIGAN
NADELHORN
NEBRASKA
NIEDERHORN
NORDEND
WILDSTRUBEL
SUSTENHORN
SNCF01