Pompage : autonome sous WSL, sans monitoring-dashboard (D-146)

- pomper.py : les lectures de l'appli recopiées en SQL, plus d'import de app/ ;
  le rattrapage reprend aussi les jours de métriques en échec
- pomper.sh : .env du projet, environnement uv jetable, log, verrou,
  post-traitement LENZSPITZE ; tâche Windows nocturne documentée
- vérifié contre l'ancien code sur NORDEND, SUSTENHORN, NADELHORN
- db/ (copie de la SQLite de l'appli) hors de git

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-12 15:55:43 +01:00
1 parent d4fea5d290
commit f62071c83f
7 files changed
+287 -99

No files matched your search

+218 -84
View File
@@ -1,16 +1,17 @@
"""Pompe les métriques système, les déplacements (export « advanced ») et les images de stations de la plateforme
AIMsight, dans le format que Support-Agent lit déjà. LECTURE SEULE. Essayé le 2026-10-26 (NORDEND, 2 jours).
AIMsight, dans le format que Support-Agent lit déjà. LECTURE SEULE. Essayé le 2026-10-26 (NORDEND, 2 jours) ;
autonome depuis le 2026-11-12 (D-146).
À lancer dans le dev container, depuis la racine de monitoring-dashboard (voir README.md) :
À lancer par extraction/pomper.sh, sous WSL, depuis n'importe où (voir README.md) :
(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --images)
(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --du 2026-08-01 --au 2026-08-08 --images WEISSHORN)
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 de déplacements manquants 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.
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/` de Support-Agent, à côté de ce dossier ; le container monte `~` sur `/workspaces`) :
Sortie (défaut : le `data/` de Support-Agent, à 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
@@ -18,14 +19,16 @@ Sortie (défaut : le `data/` de Support-Agent, à côté de ce dossier ; le cont
<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 son fichier.
qu'il est, ses métriques jusqu'à la dernière heure terminée. Pour reprendre un jour, supprimer ses fichiers.
Réutilise le code de l'appli : la requête de System.get_metrics (le téléchargement de la page System),
build_advanced_frame (ce que tracent l'onglet Advanced et l'export parquet), les mouvements de la caméra de
fetch_cam_movements_frame (ce que trace le visualiseur), AcquisitionUnit.measurements et
get_measurement_payload (S3). Connexion : même schéma que scripts/domain_diagnostics.py, un moteur dédié en lecture
seule, délai de 60 s (`--delai`). Pas DatabaseEngine : son __init__ lance du DDL et un écouteur NOTIFY. Variables lues (noms
seulement, aucune n'est affichée) : AIMSIGHT_DATABASE_USER / _PSWD / _TURL / _NAME / _PORT, et pour les images
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
@@ -35,16 +38,9 @@ import time
from datetime import datetime, timedelta, timezone
from pathlib import Path
sys.path.insert(0, os.getcwd()) # racine de l'appli : le paquet `app`
import pandas as pd
from sqlalchemy import create_engine, func, funcfilter
from sqlalchemy import create_engine, text
from sqlalchemy.engine import URL
from sqlalchemy.orm import Session
from app.aggregates import AggregateEngine
from app.aimsight_database import (DataType, DatabaseEngine, Measurement, MeasurementType, MetricSample, MetricSeries,
S3client, System)
from app.datapoints import AGGREGATE_FALLBACK_RESOLUTION, build_advanced_frame
UTC = timezone.utc
STATIONS = Path(__file__).resolve().parent / "stations.txt" # les stations suivies, une par ligne
@@ -52,17 +48,19 @@ JOURS_NOUVELLE = 30 # sans --du, une station sans déplacements pompés : les 3
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
class ReadOnlyDB:
"""Le strict nécessaire à build_advanced_frame, à camera et à get_measurement_payload (les fonctions de
DatabaseEngine)."""
get_sensor_state_aggregate = DatabaseEngine.get_sensor_state_aggregate
get_shifts_aggregate = DatabaseEngine.get_shifts_aggregate
get_common_state_aggregate = DatabaseEngine.get_common_state_aggregate
get_measurement_payload = DatabaseEngine.get_measurement_payload
def __init__(self, engine, session, s3):
self._session, self.s3client, self.aggregates = session, s3, AggregateEngine(engine)
# --- 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):
@@ -72,11 +70,16 @@ def raison(e):
return f"{type(e).__name__}: {(str(e).splitlines() or [''])[0][:300]}"
def acquisition_unit(system):
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 = list(system.acquisition_units.values())
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] if pick else None
return pick[0].id if pick else None
def plages_suivi(dossier, fin, demain):
@@ -88,21 +91,24 @@ def plages_suivi(dossier, fin, demain):
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]
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(session, system, station, debut, fin, out, remplacer):
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({n for (n,) in session.query(DataType.name).join(MetricSeries, MetricSeries.datatype_id == DataType.id)
.filter(MetricSeries.system_id == system.id).distinct()})
session.rollback()
heure = func.date_trunc("hour", MetricSample.time_utc).label("heure") # même découpage que time_bucket('1 hour')
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"
@@ -110,22 +116,22 @@ def pomper_metriques(session, system, station, debut, fin, out, remplacer):
if not remplacer and all(p.exists() for p in paths.values()):
continue
t0 = time.time()
q = (session.query(heure, DataType.name.label("nom"),
(func.avg(MetricSample.value_num) * func.any_value(DataType.transform_factor)
+ func.any_value(DataType.transform_offset)).label("num"),
funcfilter(func.jsonb_agg(MetricSample.value_text), MetricSample.value_text.isnot(None))
.label("txt"))
.select_from(MetricSample)
.join(MetricSeries, MetricSample.series_id == MetricSeries.id)
.join(DataType, MetricSeries.datatype_id == DataType.id)
.filter(MetricSeries.system_id == system.id, MetricSample.time_utc >= a,
MetricSample.time_utc < a + timedelta(days=1))
.group_by(heure, DataType.name))
try:
df = pd.read_sql(q.statement, session.bind)
# 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
@@ -140,34 +146,152 @@ def pomper_metriques(session, system, station, debut, fin, out, remplacer):
f"{time.time() - t0:.0f} s")
def camera(unit, db, a, b):
# --- 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, app/datapoints.py), sans son except, qui rendrait vide un
jour en échec au lieu de le laisser à relancer."""
df = db.get_shifts_aggregate(unit, f"cam_movements_{AGGREGATE_FALLBACK_RESOLUTION}", a, b)
return df.reset_index().drop(columns="sensor_id", errors="ignore") # sensor_id : l'id interne de l'unité
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", build_advanced_frame), ("camera", "camera", camera)) # dossier, fichier, lecture
JOURS = (("displacement", "advanced", advanced), ("camera", "camera", camera)) # dossier, fichier, lecture
def pomper_deplacements(unit, db, station, debut, fin, out, remplacer):
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, lire in JOURS:
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 = lire(unit, db, a, a + timedelta(days=1) - timedelta(microseconds=1))
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:
db._session.rollback() # ferme la transaction de lecture
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)
@@ -175,16 +299,19 @@ def pomper_deplacements(unit, db, station, debut, fin, out, remplacer):
print(f"{station} {a:%Y-%m-%d} {nom}: {len(df)} lignes, {time.time() - t0:.0f} s -> {path.name}")
def pomper_images(unit, db, session, station, debut, fin, dossier, every, out):
mt = session.query(MeasurementType).filter_by(name=TYPES[dossier]).one_or_none()
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)
q = unit.measurements.filter(Measurement.measurement_type_id == mt.id, Measurement.time_utc >= a,
Measurement.time_utc < a + timedelta(days=1)).order_by(Measurement.time_utc)
mesures = q.all()
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é) ;
@@ -200,14 +327,16 @@ def pomper_images(unit, db, session, station, debut, fin, dossier, every, out):
seen.add(bucket) # même déjà là : sinon la relance prendrait l'image suivante de la tranche
if path.exists():
continue
data = db.get_measurement_payload(m.measurement_uuid) # None si S3 ne répond pas
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
session.rollback()
# 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)")
@@ -242,30 +371,35 @@ def main():
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 = S3client(os.environ.get("AIMSIGHT_S3_URL", "http://s3:3900"), os.environ.get("AIMSIGHT_S3_ACCESS_KEY", ""),
os.environ.get("AIMSIGHT_S3_SECRET_KEY", ""),
os.environ.get("AIMSIGHT_S3_BUCKET", "measurements-assets")) if (a.images or a.diff) else None
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 Session(engine) as session:
db = ReadOnlyDB(engine, session, s3)
with engine.connect() as conn:
for station in stations:
system = session.query(System).filter_by(serial_number=station).one_or_none()
if system is None:
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(system)
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(session, system, station, debut, fin_plage, a.out, remplacer)
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(unit, db, station, debut, fin_plage, a.out, remplacer)
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(unit, db, session, station, debut, fin_plage, dossier, a.every, a.out)
pomper_images(conn, s3, unit, station, debut, fin_plage, dossier, a.every, a.out)
finally:
engine.dispose()