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
+26
-10
@@ -1,4 +1,4 @@
|
||||
# extraction/ : pomper les données de la plateforme (lecture seule, essayé le 2026-10-26)
|
||||
# extraction/ : pomper les données de la plateforme (lecture seule, essayé le 2026-10-26 ; sous WSL depuis D-146)
|
||||
|
||||
`pomper.py` récupère, pour chaque station (numéro de série du système) et chaque jour UTC demandé, dans le format que lit déjà Support-Agent :
|
||||
- les **métriques système** (énergie, disque, 4G, températures et toutes les autres de la station), moyennes horaires, un CSV par métrique et par jour dans `metrics/` : ce que lisent `src/<domaine>/` et les maquettes ;
|
||||
@@ -6,25 +6,41 @@
|
||||
- les **mouvements de la caméra** (`pan`, `tilt`, `scale`, `rotation`, `sigma0`), en médiane et bornes (`median_`, `min_`, `max_`) par minute, donc une ligne par mesure de la caméra (toutes les 15 min à NORDEND), seulement aux instants où la caméra a été recalée, un CSV par jour dans `camera/` : ce que trace le visualiseur de la plateforme, absent des exports reçus ; lus par les outils de lecture `ensemble.py` et `inventaire.py` (D-073) ;
|
||||
- les **images** IRON (`--images`, une par heure par défaut, `--every 10` ou `--every 0` pour plus) dans `images/`, et différentielles (`--diff`) dans `images_diff/`.
|
||||
|
||||
**Stations suivies** : `stations.txt`, un numéro de série par ligne. Lancé sans station ni dates, le script les met toutes à jour, jusqu'à maintenant : chaque station repart de son dernier jour de déplacements pompé, qui est repompé (pompé en cours de journée, il était incomplet) ; une station sans dossier dans `data/` reçoit les 30 derniers jours (D-096). Avant, les jours sans fichier de déplacements entre le premier et le dernier pompé (plages pompées à part, jour en échec) sont pompés, sans toucher aux autres (D-125).
|
||||
**Stations suivies** : `stations.txt`, un numéro de série par ligne. Lancé sans station ni dates, le script les met toutes à jour, jusqu'à maintenant : chaque station repart de son dernier jour de déplacements pompé, qui est repompé (pompé en cours de journée, il était incomplet) ; une station sans dossier dans `data/` reçoit les 30 derniers jours (D-096). Avant, les jours sans fichier de déplacements entre le premier et le dernier pompé (plages pompées à part, jour en échec), ou sans aucun fichier de métriques (métriques seules en échec), sont pompés, sans toucher aux autres (D-125, D-146).
|
||||
|
||||
Reprise : avec `--du`, un fichier déjà dans `data/<SERIE>/` n'est pas redemandé ; relancer sur une plage plus large ne lit que les jours et les images qui manquent. Le jour en cours est pompé tel qu'il est, ses métriques jusqu'à la dernière heure terminée ; le lancement suivant sans `--du` le remplace.
|
||||
|
||||
## Lancer (l'utilisateur, dans le dev container de l'appli)
|
||||
## Lancer (sous WSL, sans l'appli, D-146)
|
||||
|
||||
Le container monte tout `~` sur `/workspaces` (`.devcontainer/docker-compose.yml` de l'appli) : le script et `data/` de Support-Agent y sont visibles, rien à copier.
|
||||
`pomper.sh` lit les identifiants dans le `.env` de Support-Agent (base PostgreSQL et S3, sans les afficher ; jamais versionné, interdit en lecture à Claude), installe les 4 paquets nécessaires (`sqlalchemy`, `psycopg2-binary`, `pandas`, `boto3`) dans un environnement `uv` jetable (Python 3.12, téléchargé au premier lancement), lance `pomper.py`, puis `lenzspitze_absolu.py`. Sa sortie s'ajoute à `out/pompage.log` ; un second lancement pendant un pompage s'arrête aussitôt. Plus de `chown` : les fichiers sont à l'utilisateur.
|
||||
|
||||
1. VS Code sur `~/monitoring-dashboard`, « Reopen in Container », puis un terminal : il s'ouvre à la racine de l'appli, `/workspaces/monitoring-dashboard`.
|
||||
2. **Mettre à jour les stations suivies** : `(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --images); chown -R 1000:1000 /workspaces/Support-Agent/data`. Le script dit, pour chaque station, la plage qu'il pompe. Les points suivants servent à une plage choisie (historique, jour en échec).
|
||||
3. **Un essai d'abord** (1 station, 2 jours), écrit directement dans `~/Support-Agent/data/<SERIE>/` (défaut de `--out`) ; le container tourne en root, `chown` rend les fichiers à l'utilisateur de WSL :
|
||||
`(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --du 2026-07-29 --au 2026-07-31 --images --diff <SERIE>); chown -R 1000:1000 /workspaces/Support-Agent/data/<SERIE>`. Noter le temps par jour.
|
||||
4. Puis la plage voulue, avec 3 jours de plus avant (l'historique du journal), par exemple les 3 semaines avant le 26/10 : `--du 2026-10-02 --au 2026-10-26` (`--au` exclu). Plusieurs stations : `<SERIE1> <SERIE2>`. Aide : `python3 /workspaces/Support-Agent/extraction/pomper.py -h`.
|
||||
Plus de dépendance à `~/monitoring-dashboard` : les lectures de l'appli sont recopiées dans `pomper.py`, en SQL (sa docstring dit lesquelles, et de quel commit). Vérifié le 2026-11-12 contre les fichiers pompés le matin même par l'ancien code : NORDEND (déplacements bruts, 2 jours, images comprises), SUSTENHORN (agrégés), NADELHORN (bruts et agrégés fusionnés), mêmes fichiers à l'octet, sauf l'heure des lignes agrégées de NADELHORN, écrite `00:00:00.000000+00:00` au lieu de `00:00:00+00:00` (mêmes valeurs ; `fromisoformat` lit les deux). Si l'appli change ses lectures, le script ne suit pas : comparer à nouveau.
|
||||
|
||||
1. **Un essai** (1 station, 2 jours, dans un dossier jetable) ; noter le temps par jour :
|
||||
`extraction/pomper.sh --du 2026-11-09 --au 2026-11-11 --images --out /tmp/essai-pompage NORDEND` (6 s le 2026-11-12, base et S3 joints depuis WSL).
|
||||
2. **Mettre à jour les stations suivies** : `extraction/pomper.sh` (sans argument : `--images --delai 300`). Le script dit, pour chaque station, la plage qu'il pompe.
|
||||
3. **Une plage choisie** (historique, jour en échec), avec 3 jours de plus avant (l'historique du journal) : `extraction/pomper.sh --du 2026-10-02 --au 2026-10-26 --images <SERIE>` (`--au` exclu ; plusieurs stations : `<SERIE1> <SERIE2>`). Aide : `extraction/pomper.sh -h`.
|
||||
|
||||
**Chaque nuit, automatiquement** : une tâche du Planificateur de tâches de Windows, à créer une fois dans PowerShell (pas en administrateur). Elle démarre WSL au besoin et, PC éteint ou en veille à l'heure dite, part dès qu'il se rallume ; un jour manqué est rattrapé au lancement suivant.
|
||||
|
||||
```powershell
|
||||
$a = New-ScheduledTaskAction -Execute "wsl.exe" -Argument "-d Ubuntu -e bash -lc /home/maxime/Support-Agent/extraction/pomper.sh"
|
||||
$t = New-ScheduledTaskTrigger -Daily -At 04:00
|
||||
$s = New-ScheduledTaskSettingsSet -StartWhenAvailable -ExecutionTimeLimit (New-TimeSpan -Hours 6)
|
||||
Register-ScheduledTask -TaskName "AIMsight pompage" -Action $a -Trigger $t -Settings $s
|
||||
```
|
||||
|
||||
Essayer la tâche tout de suite : `Start-ScheduledTask "AIMsight pompage"`, puis lire `out/pompage.log`. La retirer : `Unregister-ScheduledTask "AIMsight pompage"`.
|
||||
|
||||
Le dev container de l'appli ne sert plus.
|
||||
|
||||
Lecture seule : moteur dédié, `default_transaction_read_only`, délai de 60 s par requête, une requête par jour ; hors des heures chargées (base partagée avec la production).
|
||||
|
||||
## Avec Claude
|
||||
|
||||
Claude ne se connecte pas à la base (règle de l'appli) : il lit `data/<SERIE>/`, donne la commande des jours manquants, puis vérifie ce qui arrive (comparaison à un export reçu, `detectors/categories.py`, les scripts des domaines).
|
||||
Claude peut lancer `pomper.sh` lui-même (accord de l'utilisateur, 2026-11-12, D-146) : lecture seule, petites plages ; une longue plage ou un historique, hors des heures chargées. Il ne lit jamais le `.env`. Puis il vérifie ce qui arrive (comparaison à un export reçu, `detectors/categories.py`, les scripts des domaines).
|
||||
|
||||
**La base de l'appli** (SQLite : appareils et leur nom chez le client, sorties, alarmes, utilisateurs) : une copie dans `db/database.db`, hors de git, du 2026-11-12 ; le pompage ne s'en sert pas. Elle servira au nom du site client → numéro de série et aux déplacements en mm ; ne lire que les tables utiles (pas `User`).
|
||||
|
||||
## À savoir
|
||||
|
||||
|
||||
+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()
|
||||
|
||||
|
||||
Executable
+25
@@ -0,0 +1,25 @@
|
||||
#!/usr/bin/env bash
|
||||
# Pompage sous WSL, sans l'appli monitoring-dashboard (D-146). Lit les identifiants dans le .env de Support-Agent,
|
||||
# lance pomper.py dans un environnement uv jetable (4 paquets), puis le post-traitement de LENZSPITZE.
|
||||
# extraction/pomper.sh mise à jour des stations suivies, images comprises (le planificateur)
|
||||
# extraction/pomper.sh --du D --au F [SERIE] tout autre appel : les arguments vont tels quels à pomper.py
|
||||
# Sortie ajoutée à out/pompage.log ; un seul pompage à la fois (verrou out/pompage.lock).
|
||||
set -u
|
||||
export PATH="$HOME/.local/bin:$PATH" # uv, absent du PATH quand le Planificateur de tâches lance wsl.exe
|
||||
ici=$(cd "$(dirname "$0")" && pwd)
|
||||
racine=$(dirname "$ici")
|
||||
mkdir -p "$racine/out"
|
||||
|
||||
exec 9>"$racine/out/pompage.lock"
|
||||
flock -n 9 || { echo "Un pompage tourne déjà." >&2; exit 1; }
|
||||
|
||||
[ $# -eq 0 ] && set -- --images --delai 300
|
||||
{
|
||||
echo "=== $(date -u +%Y-%m-%dT%H:%MZ) pomper.py $*"
|
||||
(set -a && . "$racine/.env" && set +a &&
|
||||
uv run --no-project --quiet --python 3.12 \
|
||||
--with sqlalchemy --with psycopg2-binary --with pandas --with boto3 \
|
||||
python "$ici/pomper.py" "$@")
|
||||
[ -f "$racine/data/LENZSPITZE/lentzpitze_patterns.json" ] && python3 "$ici/lenzspitze_absolu.py"
|
||||
echo "=== $(date -u +%Y-%m-%dT%H:%MZ) fin"
|
||||
} 2>&1 | tee -a "$racine/out/pompage.log"
|
||||
Reference in new issue
Block a user