Files
Support-Agent/extraction/pomper.py
T
maximeandClaude Opus 5.5 a81cc4c380 Pump system metrics and resume day by day (point 43)
pomper.py now also pumps every system metric of a station, in the format of
the System page download (hourly mean, text lists, empty hour), one CSV per
metric and per day; displacements are written one file per day, today is
never pumped, and a rerun only fetches missing days. Fix image resume: an
image already on disk now counts for its time slot. load_stations merges
several files of the same metric instead of failing on a duplicate.

Not run against the database: first run by the user, with point 27.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 19:14:59 +02:00

208 lines
12 KiB
Python

"""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. Brouillon, jamais lancé.
À lancer dans le dev container, depuis la racine de monitoring-dashboard (voir README.md) :
(set -a && . ./.env && set +a && python3 extraction/pomper.py --du 2026-08-01 --au 2026-08-08 --images WEISSHORN)
Sortie (défaut `extraction/sortie/`), à copier ensuite dans Support-Agent/data/ :
<STATION>/<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>/images/<AAAAMMJJ>T<HHMM>Z_<id>.<ext> images OPTICAL_SHIFT-IRON (--images)
<STATION>/images_diff/… images différentielles (--diff)
Reprenable : un fichier déjà écrit n'est pas relu, quelles que soient les dates demandées. Jours en UTC, `--au` exclu,
jamais le jour en cours (il serait figé incomplet). Pour reprendre un jour, supprimer son fichier.
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), 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. 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
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
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.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 build_advanced_frame
UTC = timezone.utc
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 et à get_measurement_payload (les fonctions de DatabaseEngine)."""
get_sensor_state_aggregate = DatabaseEngine.get_sensor_state_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)
def acquisition_unit(system):
"""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())
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
def pomper_metriques(session, system, station, debut, fin, out):
"""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')
for k in range((fin - debut).days):
a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC)
paths = {n: out / station / 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 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)
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 ({type(e).__name__}), à relancer")
continue
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
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")
def pomper_deplacements(unit, db, station, debut, fin, out):
for k in range((fin - debut).days): # un fichier et une requête par jour : bornée, sous le délai de 60 s
a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC)
path = out / station / "displacement" / f"{station}_advanced_{a:%Y%m%d}.csv"
if path.exists():
continue
t0 = time.time()
try:
df = build_advanced_frame(unit, db, 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} : échec ({type(e).__name__}), à relancer")
continue
finally:
db._session.rollback() # ferme la transaction de lecture
if len(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}: {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()
if mt is None:
print(f"{station} : type {TYPES[dossier]} inconnu")
return
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)
seen, n, octets = set(), 0, 0
for m in q.all():
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
data = db.get_measurement_payload(m.measurement_uuid) # None si S3 ne répond pas
if data:
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(data)
n, octets = n + 1, octets + len(data)
session.rollback()
print(f"{station} {a:%Y-%m-%d} {dossier}: {n} images, {octets / 1e6:.0f} Mo")
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")
p.add_argument("--du", required=True, help="premier jour UTC, AAAA-MM-JJ")
p.add_argument("--au", required=True, help="dernier jour UTC exclu, AAAA-MM-JJ")
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("--out", type=Path, default=Path("extraction/sortie"))
a = p.parse_args()
debut, fin = (datetime.strptime(x, "%Y-%m-%d").date() for x in (a.du, a.au))
aujourdhui = datetime.now(UTC).date()
if fin > aujourdhui: # ponytail : un jour passé, encore en synchronisation, reste figé ; supprimer son fichier
print(f"--au ramené à {aujourdhui} : le jour en cours n'est pas fini")
fin = aujourdhui
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": "-c timezone=utc -c default_transaction_read_only=on -c statement_timeout=60s"})
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
try:
with Session(engine) as session:
db = ReadOnlyDB(engine, session, s3)
for station in a.stations:
system = session.query(System).filter_by(serial_number=station).one_or_none()
if system is None:
print(f"{station} : système inconnu")
continue
pomper_metriques(session, system, station, debut, fin, a.out)
unit = acquisition_unit(system)
if unit is None:
print(f"{station} : pas d'unité d'acquisition reconnue, ni déplacements ni images")
continue
pomper_deplacements(unit, db, station, debut, fin, a.out)
for flag, dossier in ((a.images, "images"), (a.diff, "images_diff")):
if flag:
pomper_images(unit, db, session, station, debut, fin, dossier, a.every, a.out)
finally:
engine.dispose()
if __name__ == "__main__":
main()