Files
Support-Agent/extraction/pomper.py
T
maximeandClaude Opus 5.5 3ec6261b5a Pump the camera movements and add run.md with the generic pump command (point 43)
Camera pan, tilt, scale, rotation and sigma0, one row per camera measurement,
read like the platform viewer (cam_movements aggregate), one CSV per day in
camera/. Tried on NORDEND 30/07: 70 poses out of 95 instants, sigma0 on the
same 7 as the advanced export. run.md holds the command to copy into the
app's dev container.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 11:27:06 +01:00

235 lines
14 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. Essayé le 2026-10-26 (NORDEND, 2 jours).
À lancer dans le dev container, depuis la racine de monitoring-dashboard (voir README.md) :
(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --du 2026-08-01 --au 2026-08-08 --images WEISSHORN)
Sortie (défaut : le `data/` de Support-Agent, à côté de ce dossier ; le container monte `~` sur `/workspaces`) :
<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>/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 : 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), 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
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 AGGREGATE_FALLBACK_RESOLUTION, 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, à 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)
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 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 ({raison(e)}), à 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 camera(unit, db, 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é
JOURS = (("displacement", "advanced", build_advanced_frame), ("camera", "camera", camera)) # dossier, fichier, lecture
def pomper_deplacements(unit, db, station, debut, fin, out):
"""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:
path = out / station / dossier / f"{station}_{nom}_{a:%Y%m%d}.csv"
if path.exists():
continue
t0 = time.time()
try:
df = lire(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} {nom} : échec ({raison(e)}), à relancer")
continue
finally:
db._session.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(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} nouvelles 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("--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()
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": 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
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 caméra, 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()