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:
1 parent
d4fea5d290
commit
f62071c83f
7 files changed
+287
-99
No files matched your search
+218
-84
@@ -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()
|
||||
|
||||
|
||||
Reference in new issue
Block a user