"""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) ; autonome depuis le 2026-11-12 (D-146). À lancer par extraction/pomper.sh, sous WSL, depuis n'importe où (voir README.md) : 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 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) : /metrics/___00_00 to _23_00.csv métriques système, par jour /displacement/_advanced_.csv déplacements, un fichier par jour /camera/_camera_.csv mouvements de la caméra, par jour /images/TZ_. images OPTICAL_SHIFT-IRON (--images) /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 ses fichiers. 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 import os import sys import time from datetime import datetime, timedelta, timezone from pathlib import Path import pandas as pd from sqlalchemy import create_engine, text from sqlalchemy.engine import URL UTC = timezone.utc 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 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 # --- 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): """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 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 = 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].id if pick else None def plages_suivi(dossier, fin, demain): """Sans --du : (début, fin, remplacer) à pomper, d'après les jours de déplacements déjà pompés. Les jours manquants entre le premier et le dernier (plages pompées à part, jour en échec) sont comblés sans toucher aux autres ; le dernier jour est repompé (pompé en cours de journée, il était incomplet) jusqu'à maintenant ; une station sans déplacements pompés reçoit les 30 derniers jours.""" jours = {datetime.strptime(p.stem.rsplit("_", 1)[1], "%Y%m%d").date() 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 or (metriques and premier + timedelta(days=k) not in metriques)] return ([(trous[0], dernier, False)] if trous else []) + [(dernier, fin, True)] 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(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" / 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 not remplacer and all(p.exists() for p in paths.values()): continue t0 = time.time() try: # 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 heures = heures[heures + pd.Timedelta(hours=1) <= pd.Timestamp.now(tz=UTC)] 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") # --- 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), 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", advanced), ("camera", "camera", camera)) # dossier, fichier, lecture 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, 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 = 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: 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) 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(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) 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é) ; # écartée, la tranche prend l'image suivante s'il y en a une if m.measurement_uuid is None: sans_uuid += 1 continue 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 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 # 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)") 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 ; " "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") 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() 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() 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 = 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 engine.connect() as conn: for station in stations: 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(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(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(conn, unit, station, debut, fin_plage, a.out, remplacer) for flag, dossier in ((a.images, "images"), (a.diff, "images_diff")): if flag: pomper_images(conn, s3, unit, station, debut, fin_plage, dossier, a.every, a.out) finally: engine.dispose() if __name__ == "__main__": main()