2026-10-24 19:14:59 +02:00
|
|
|
"""Pompe les métriques système, les déplacements (export « advanced ») et les images de stations de la plateforme
|
2026-10-26 11:13:57 +01:00
|
|
|
AIMsight, dans le format que Support-Agent lit déjà. LECTURE SEULE. Essayé le 2026-10-26 (NORDEND, 2 jours).
|
2026-10-23 21:52:08 +02:00
|
|
|
|
2026-10-24 14:31:42 +02:00
|
|
|
À lancer dans le dev container, depuis la racine de monitoring-dashboard (voir README.md) :
|
2026-10-23 21:52:08 +02:00
|
|
|
|
2026-10-29 17:10:08 +01:00
|
|
|
(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --images)
|
2026-10-26 11:13:57 +01:00
|
|
|
(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --du 2026-08-01 --au 2026-08-08 --images WEISSHORN)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
2026-10-29 17:10:08 +01:00
|
|
|
Sans station : celles de `stations.txt`. Sans `--du` : chaque station repart de son dernier jour de déplacements pompé,
|
|
|
|
|
repompé (il était peut-être incomplet), ou des 30 derniers jours si elle n'en a pas ; sans `--au` : jusqu'à maintenant.
|
|
|
|
|
|
2026-10-26 11:13:57 +01:00
|
|
|
Sortie (défaut : le `data/` de Support-Agent, à côté de ce dossier ; le container monte `~` sur `/workspaces`) :
|
2026-10-26 16:47:47 +01:00
|
|
|
<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)
|
2026-10-29 17:10:08 +01:00
|
|
|
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.
|
2026-10-24 19:14:59 +02:00
|
|
|
|
|
|
|
|
Réutilise le code de l'appli : la requête de System.get_metrics (le téléchargement de la page System),
|
2026-10-26 11:27:06 +01:00
|
|
|
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
|
2026-10-24 19:14:59 +02:00
|
|
|
get_measurement_payload (S3). Connexion : même schéma que scripts/domain_diagnostics.py, un moteur dédié en lecture
|
2026-10-26 11:13:57 +01:00
|
|
|
seule, délai de 60 s (`--delai`). Pas DatabaseEngine : son __init__ lance du DDL et un écouteur NOTIFY. Variables lues (noms
|
2026-10-24 19:14:59 +02:00
|
|
|
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.
|
2026-10-23 21:52:08 +02:00
|
|
|
"""
|
|
|
|
|
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
|
2026-10-24 19:14:59 +02:00
|
|
|
from sqlalchemy import create_engine, func, funcfilter
|
2026-10-23 21:52:08 +02:00
|
|
|
from sqlalchemy.engine import URL
|
|
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
|
|
|
|
|
|
from app.aggregates import AggregateEngine
|
2026-10-24 19:14:59 +02:00
|
|
|
from app.aimsight_database import (DataType, DatabaseEngine, Measurement, MeasurementType, MetricSample, MetricSeries,
|
|
|
|
|
S3client, System)
|
2026-10-26 11:27:06 +01:00
|
|
|
from app.datapoints import AGGREGATE_FALLBACK_RESOLUTION, build_advanced_frame
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
UTC = timezone.utc
|
2026-10-29 17:10:08 +01:00
|
|
|
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
|
2026-10-23 21:52:08 +02:00
|
|
|
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:
|
2026-10-26 11:27:06 +01:00
|
|
|
"""Le strict nécessaire à build_advanced_frame, à camera et à get_measurement_payload (les fonctions de
|
|
|
|
|
DatabaseEngine)."""
|
2026-10-23 21:52:08 +02:00
|
|
|
get_sensor_state_aggregate = DatabaseEngine.get_sensor_state_aggregate
|
2026-10-26 11:27:06 +01:00
|
|
|
get_shifts_aggregate = DatabaseEngine.get_shifts_aggregate
|
2026-10-23 21:52:08 +02:00
|
|
|
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)
|
|
|
|
|
|
|
|
|
|
|
2026-10-26 11:13:57 +01:00
|
|
|
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]}"
|
|
|
|
|
|
|
|
|
|
|
2026-10-24 19:14:59 +02:00
|
|
|
def acquisition_unit(system):
|
2026-10-23 21:52:08 +02:00
|
|
|
"""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"))]
|
2026-10-24 19:14:59 +02:00
|
|
|
return pick[0] if pick else None
|
|
|
|
|
|
|
|
|
|
|
2026-10-29 17:10:08 +01:00
|
|
|
def dernier_jour(dossier):
|
|
|
|
|
"""Jour du dernier fichier de déplacements pompé dans le dossier de la station, ou None."""
|
|
|
|
|
jours = [p.stem.rsplit("_", 1)[1] for p in (dossier / "displacement").glob("*_advanced_*.csv")]
|
|
|
|
|
return datetime.strptime(max(jours), "%Y%m%d").date() if jours else None
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def pomper_metriques(session, system, station, debut, fin, out, remplacer):
|
2026-10-24 19:14:59 +02:00
|
|
|
"""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)
|
2026-10-26 16:47:47 +01:00
|
|
|
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}
|
2026-10-29 17:10:08 +01:00
|
|
|
if not remplacer and all(p.exists() for p in paths.values()):
|
2026-10-24 19:14:59 +02:00
|
|
|
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
|
2026-10-26 11:13:57 +01:00
|
|
|
print(f"{station} {a:%Y-%m-%d} métriques : échec ({raison(e)}), à relancer")
|
2026-10-24 19:14:59 +02:00
|
|
|
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
|
2026-10-29 17:10:08 +01:00
|
|
|
# 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)]
|
2026-10-24 19:14:59 +02:00
|
|
|
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")
|
|
|
|
|
|
|
|
|
|
|
2026-10-26 11:27:06 +01:00
|
|
|
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
|
|
|
|
|
|
|
|
|
|
|
2026-10-29 17:10:08 +01:00
|
|
|
def pomper_deplacements(unit, db, station, debut, fin, out, remplacer):
|
2026-10-26 11:27:06 +01:00
|
|
|
"""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):
|
2026-10-24 19:14:59 +02:00
|
|
|
a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC)
|
2026-10-26 11:27:06 +01:00
|
|
|
for dossier, nom, lire in JOURS:
|
|
|
|
|
path = out / station / dossier / f"{station}_{nom}_{a:%Y%m%d}.csv"
|
2026-10-29 17:10:08 +01:00
|
|
|
if path.exists() and not remplacer:
|
2026-10-26 11:27:06 +01:00
|
|
|
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}")
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
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)
|
2026-10-28 14:23:54 +01:00
|
|
|
q = unit.measurements.filter(Measurement.measurement_type_id == mt.id, Measurement.time_utc >= a,
|
2026-10-23 21:52:08 +02:00
|
|
|
Measurement.time_utc < a + timedelta(days=1)).order_by(Measurement.time_utc)
|
2026-10-28 14:23:54 +01:00
|
|
|
mesures = q.all()
|
|
|
|
|
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
|
2026-10-23 21:52:08 +02:00
|
|
|
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}"
|
2026-10-24 19:14:59 +02:00
|
|
|
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():
|
2026-10-23 21:52:08 +02:00
|
|
|
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)
|
2026-10-28 14:23:54 +01:00
|
|
|
else:
|
|
|
|
|
absentes += 1
|
2026-10-23 21:52:08 +02:00
|
|
|
session.rollback()
|
2026-10-28 14:23:54 +01:00
|
|
|
# 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)")
|
2026-10-23 21:52:08 +02:00
|
|
|
time.sleep(0.5)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def main():
|
|
|
|
|
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
2026-10-29 17:10:08 +01:00
|
|
|
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")
|
2026-10-23 21:52:08 +02:00
|
|
|
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)")
|
2026-10-26 11:13:57 +01:00
|
|
|
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")
|
2026-10-23 21:52:08 +02:00
|
|
|
a = p.parse_args()
|
2026-10-29 17:10:08 +01:00
|
|
|
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()
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
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={
|
2026-10-26 11:13:57 +01:00
|
|
|
"options": f"-c timezone=utc -c default_transaction_read_only=on -c statement_timeout={a.delai}s"})
|
2026-10-23 21:52:08 +02:00
|
|
|
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)
|
2026-10-29 17:10:08 +01:00
|
|
|
for station in stations:
|
2026-10-24 19:14:59 +02:00
|
|
|
system = session.query(System).filter_by(serial_number=station).one_or_none()
|
|
|
|
|
if system is None:
|
|
|
|
|
print(f"{station} : système inconnu")
|
|
|
|
|
continue
|
2026-10-29 17:10:08 +01:00
|
|
|
# sans --du : du dernier jour pompé, remplacé (pompé en cours de journée, il est incomplet), jusqu'à
|
|
|
|
|
# maintenant ; les jours plus anciens manquants restent à la commande avec --du
|
|
|
|
|
debut = du or dernier_jour(a.out / station) or demain - timedelta(days=JOURS_NOUVELLE + 1)
|
|
|
|
|
print(f"{station} : du {debut} au {fin - timedelta(days=1)} inclus")
|
|
|
|
|
pomper_metriques(session, system, station, debut, fin, a.out, du is None)
|
2026-10-24 19:14:59 +02:00
|
|
|
unit = acquisition_unit(system)
|
|
|
|
|
if unit is None:
|
2026-10-26 11:27:06 +01:00
|
|
|
print(f"{station} : pas d'unité d'acquisition reconnue, ni déplacements, ni caméra, ni images")
|
2026-10-24 19:14:59 +02:00
|
|
|
continue
|
2026-10-29 17:10:08 +01:00
|
|
|
pomper_deplacements(unit, db, station, debut, fin, a.out, du is None)
|
2026-10-23 21:52:08 +02:00
|
|
|
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()
|