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:
maximeandClaude Opus 5.5 committed 2026-11-12 15:55:43 +01:00
1 parent d4fea5d290
commit f62071c83f
7 files changed
+287 -99

No files matched your search

+2
View File
@@ -25,3 +25,5 @@ labeling/auto/revue-croisee/**
!labeling/auto/revue-croisee/**/modifications.jsonl !labeling/auto/revue-croisee/**/modifications.jsonl
!labeling/auto/revue-croisee/**/outils/*.py !labeling/auto/revue-croisee/**/outils/*.py
.superpowers/ .superpowers/
# accès à la base SQLite de l'appli (appareils, utilisateurs) : jamais versionné
db/
+3 -2
View File
@@ -119,7 +119,7 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .
- `support/` : un dossier par demande d'un client (D-079), `<date>_<STATION>_<sujet>/` : `demande.md`, `analyse.md`, `reponse.md` (le mail prêt à envoyer), GIF des images ; ou `<date>_<STATION>_rapport-situation/` : `rapport.md`, ses images, `<station>.typ` (le source) et `<station>.pdf`, nom de la station en minuscules. Contient des mails et images de clients. - `support/` : un dossier par demande d'un client (D-079), `<date>_<STATION>_<sujet>/` : `demande.md`, `analyse.md`, `reponse.md` (le mail prêt à envoyer), GIF des images ; ou `<date>_<STATION>_rapport-situation/` : `rapport.md`, ses images, `<station>.typ` (le source) et `<station>.pdf`, nom de la station en minuscules. Contient des mails et images de clients.
- `API/` : le support par l'API Claude (D-133), un sous-projet autonome : sa doc dans `API/README.md`, ses copies dans `API/PROVENANCE.md` ; les agents Claude Code n'y lisent rien, et lui ne lit rien du reste du dépôt hors de `data/`. - `API/` : le support par l'API Claude (D-133), un sous-projet autonome : sa doc dans `API/README.md`, ses copies dans `API/PROVENANCE.md` ; les agents Claude Code n'y lisent rien, et lui ne lit rien du reste du dépôt hors de `data/`.
- `app/` : la web app (D-137, D-138), sa doc dans `app/README.md` : `serveur/` (FastAPI), `web/` (React, Mantine) ; pages Support (pilote les agents de `API/`), Data (comme `labeling.py`, et les images comme `view.py`, avec les événements des détecteurs ; elle écrit dans `labeling/`). - `app/` : la web app (D-137, D-138), sa doc dans `app/README.md` : `serveur/` (FastAPI), `web/` (React, Mantine) ; pages Support (pilote les agents de `API/`), Data (comme `labeling.py`, et les images comme `view.py`, avec les événements des détecteurs ; elle écrit dans `labeling/`).
- `extraction/` : pompage `pomper.py` des données de la plateforme (D-056), en lecture seule, lancé par l'utilisateur dans le dev container de l'application de référence `~/monitoring-dashboard` ; sans argument, il met à jour jusqu'à maintenant les stations de `stations.txt` (D-096) ; mode d'emploi `extraction/README.md`. - `extraction/` : pompage `pomper.py` des données de la plateforme (D-056), en lecture seule, lancé chaque nuit par le Planificateur de tâches de Windows, ou à la main (par l'utilisateur ou Claude), par `pomper.sh` sous WSL, sans dépendance à `~/monitoring-dashboard` : identifiants dans `.env`, lectures de l'appli recopiées en SQL (D-146) ; sans argument, il met à jour jusqu'à maintenant les stations de `stations.txt` (D-096) ; mode d'emploi `extraction/README.md`.
### Code, données, configuration ### Code, données, configuration
@@ -130,8 +130,9 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .
- WEISSHORN et NORDEND contiennent des identifiants (`SIM_CCID`, `ip`, `ip_*`) : ne pas les recopier. - WEISSHORN et NORDEND contiennent des identifiants (`SIM_CCID`, `ip`, `ip_*`) : ne pas les recopier.
- Les données des events restent, codées, dans `events/`. - Les données des events restent, codées, dans `events/`.
- `.claude/` : `rules/analyses.md` ; `agents/` : `diagnostic`, ceux de `/detector-learner` (`detectors-critic`, `detectors-upgrader`, `detectors-control`), `analyste`, `tool-builder` et `event-builder` (hors de la séance depuis D-112), `revue` (`/review-event`), `documentaliste` (`/labels-learner`, D-099), `etiqueteur` (étiquettes automatiques, D-106), `releveur` et `ameliorateur` (D-060, D-071) ; `skills/` : `support`, `presentation` (D-114), `detector-learner` (D-116), `events-learner`, `analyser-lot`, `lire-les-donnees`, `read-event`, `new-event`, `review-event`, `labels-learner` (D-099), `review-labels` (D-103), `review-auto-labels` (D-128), `cross-review-labels` (D-130), `labels-map` (D-104), `anonymize-event` (D-049, D-050), `nouvelle-analyse`, `nouveau-domaine` ; `settings.json` (lecture de `.env` interdite). - `.claude/` : `rules/analyses.md` ; `agents/` : `diagnostic`, ceux de `/detector-learner` (`detectors-critic`, `detectors-upgrader`, `detectors-control`), `analyste`, `tool-builder` et `event-builder` (hors de la séance depuis D-112), `revue` (`/review-event`), `documentaliste` (`/labels-learner`, D-099), `etiqueteur` (étiquettes automatiques, D-106), `releveur` et `ameliorateur` (D-060, D-071) ; `skills/` : `support`, `presentation` (D-114), `detector-learner` (D-116), `events-learner`, `analyser-lot`, `lire-les-donnees`, `read-event`, `new-event`, `review-event`, `labels-learner` (D-099), `review-labels` (D-103), `review-auto-labels` (D-128), `cross-review-labels` (D-130), `labels-map` (D-104), `anonymize-event` (D-049, D-050), `nouvelle-analyse`, `nouveau-domaine` ; `settings.json` (lecture de `.env` interdite).
- `db/database.db` : copie de la base SQLite de l'appli (appareils, noms des sites clients, alarmes, utilisateurs), hors de git (D-146).
- `.devcontainer/` : environnement de dev en conteneur (D-038), réseau de l'hôte pour joindre la caméra. `out/` : pages et JSON générés. - `.devcontainer/` : environnement de dev en conteneur (D-038), réseau de l'hôte pour joindre la caméra. `out/` : pages et JSON générés.
- Tout est versionné (D-014), sauf `out/`, les figures et sorties de `labeling/auto/etiqueteur/`, `data/`, `.venv/`, `__pycache__/`, `graphify-out/` et `.env`. - Tout est versionné (D-014), sauf `out/`, les figures et sorties de `labeling/auto/etiqueteur/`, `data/`, `db/`, `.venv/`, `__pycache__/`, `graphify-out/` et `.env`.
## Règles de travail ## Règles de travail
+8
View File
@@ -1334,3 +1334,11 @@ Règles du journal :
- **Pourquoi** : rester aligné sur l'infrastructure de l'entreprise (Gitea et LibreDesk), ne dépendre ni du poste ni d'un service maison ; ce sont de vrais mails de clients : aucun envoi automatique (spec de Maxime et Claude, `Support-AI/docs/spec.md`, 2026-11-09). - **Pourquoi** : rester aligné sur l'infrastructure de l'entreprise (Gitea et LibreDesk), ne dépendre ni du poste ni d'un service maison ; ce sont de vrais mails de clients : aucun envoi automatique (spec de Maxime et Claude, `Support-AI/docs/spec.md`, 2026-11-09).
- **Options écartées** : l'assistant IA de LibreDesk (il répond lui-même au client par mail et ne lit pas les notes privées, vérifié dans le code de LibreDesk v2.9) ; un bouton qui reprend la proposition dans la réponse (« Générer une réponse » et un outil à nous : il faut un service web toujours allumé, trop de complexité pour l'instant ; `Support-AI/docs/pistes.md`) ; le brouillon de réponse (rangé par utilisateur, invisible des humains) ; déployer la web app `app/`. - **Options écartées** : l'assistant IA de LibreDesk (il répond lui-même au client par mail et ne lit pas les notes privées, vérifié dans le code de LibreDesk v2.9) ; un bouton qui reprend la proposition dans la réponse (« Générer une réponse » et un outil à nous : il faut un service web toujours allumé, trop de complexité pour l'instant ; `Support-AI/docs/pistes.md`) ; le brouillon de réponse (rangé par utilisateur, invisible des humains) ; déployer la web app `app/`.
- **Conséquence** : vérifié de bout en bout le 2026-11-09 sur le mail de test de Maxime (note posée par « Agent IA », puis simulation par Gitea Actions). Le runner n'a pas les données des stations : les notes disent qu'elles manquent, à régler avant un diagnostic utile. Les copies de `API/` vieillissent comme celles de D-133 ; les vérifications de LibreDesk et Gitea sont dans `Support-AI/docs/verifications.md`. - **Conséquence** : vérifié de bout en bout le 2026-11-09 sur le mail de test de Maxime (note posée par « Agent IA », puis simulation par Gitea Actions). Le runner n'a pas les données des stations : les notes disent qu'elles manquent, à régler avant un diagnostic utile. Les copies de `API/` vieillissent comme celles de D-133 ; les vérifications de LibreDesk et Gitea sont dans `Support-AI/docs/verifications.md`.
## D-146 — 2026-11-12 — Le pompage automatique sous WSL, sans l'appli monitoring-dashboard
- **Statut** : adoptée, vérifiée le 2026-11-12. Complète D-056 et D-096.
- **Décision** : `extraction/pomper.sh` lance `pomper.py` sous WSL, chaque nuit par le Planificateur de tâches de Windows (`wsl.exe`), ou à la main, par l'utilisateur ou par Claude (accord de l'utilisateur, en lecture seule ; Claude ne lit jamais le `.env`). Aucune dépendance à `~/monitoring-dashboard` : les identifiants (PostgreSQL, S3) sont dans le `.env` de Support-Agent ; les lectures de l'appli (`System.get_metrics`, `build_advanced_frame` avec `get_datapoints` et les états agrégés, `get_cam_scalar_aggregate`, `get_measurement_payload`) sont recopiées en SQL dans `pomper.py` (commit 3dce73d de la branche `explo`) ; 4 paquets (`sqlalchemy`, `psycopg2-binary`, `pandas`, `boto3`) dans un environnement `uv` jetable, Python 3.12 ; puis `lenzspitze_absolu.py` ; sortie dans `out/pompage.log`, un seul pompage à la fois (`flock`). Le rattrapage sans `--du` compte aussi comme trou un jour de déplacements sans aucun fichier de métriques (échec des métriques seules : NADELHORN, du 06 au 09.11). La base SQLite de l'appli est copiée dans `db/database.db`, hors de git ; le pompage ne s'en sert pas.
- **Pourquoi** : l'utilisateur ne veut plus dépendre du projet de l'appli (2026-11-12). Le container n'apportait que les paquets, le code `app/`, le `.env` et le réseau ; WSL atteint la base et le S3. Le Planificateur Windows démarre WSL au besoin, ce que ne fait pas un timer systemd ou un cron de WSL ; un lancement manqué est rattrapé au suivant.
- **Options écartées** : importer `app/` depuis `~/monitoring-dashboard` (la dépendance que l'utilisateur refuse) ; copier ses modules entiers (4 500 lignes, dont `DatabaseEngine` et son DDL) ; un timer systemd ou un cron dans WSL (WSL éteint, rien ne part) ; ajouter les paquets à `.venv` (il reste aux graphiques).
- **Conséquence** : vérifié contre les fichiers de l'ancien code, pompés le matin même : NORDEND (bruts, 2 jours, images), SUSTENHORN (agrégés), NADELHORN (fusionnés) identiques à l'octet, sauf l'heure des lignes agrégées fusionnées, écrite avec `.000000` (mêmes valeurs). Si l'appli change ses lectures, `pomper.py` ne suit pas : comparer à nouveau. La copie de la SQLite vieillit : la recopier au besoin.
+26 -10
View File
@@ -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 : `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 ; - 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 **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/`. - 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. 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`. 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.
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 : 1. **Un essai** (1 station, 2 jours, dans un dossier jetable) ; noter le temps par jour :
`(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. `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).
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`. 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). 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 ## 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 ## À savoir
+218 -84
View File
@@ -1,16 +1,17 @@
"""Pompe les métriques système, les déplacements (export « advanced ») et les images de stations de la plateforme """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) extraction/pomper.sh
(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 --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 Sans station : celles de `stations.txt`. Sans `--du` : chaque station comble ses jours manquants (déplacements ou
le dernier pompé, puis repart de ce dernier jour, repompé (il était peut-être incomplet), ou des 30 derniers jours si métriques) avant le dernier pompé, puis repart de ce dernier jour, repompé (il était peut-être incomplet), ou des 30
elle n'en a pas ; sans `--au` : jusqu'à maintenant. 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>/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>/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>/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) <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`, 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 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), Sans dépendance à l'appli (~/monitoring-dashboard) : ses lectures sont recopiées ici, en SQL, telles quelles (branche
build_advanced_frame (ce que tracent l'onglet Advanced et l'export parquet), les mouvements de la caméra de `explo`, commit 3dce73d du 2026-11-12) : la requête de System.get_metrics (le téléchargement de la page System) ;
fetch_cam_movements_frame (ce que trace le visualiseur), AcquisitionUnit.measurements et build_advanced_frame (app/datapoints.py, ce que tracent l'onglet Advanced et l'export parquet), avec
get_measurement_payload (S3). Connexion : même schéma que scripts/domain_diagnostics.py, un moteur dédié en lecture AcquisitionUnit.get_datapoints et AggregateEngine.get_sensor_aggregate / get_common_aggregate ; les mouvements de la
seule, délai de 60 s (`--delai`). Pas DatabaseEngine : son __init__ lance du DDL et un écouteur NOTIFY. Variables lues (noms caméra de fetch_cam_movements_frame (AggregateEngine.get_cam_scalar_aggregate, ce que trace le visualiseur) ;
seulement, aucune n'est affichée) : AIMSIGHT_DATABASE_USER / _PSWD / _TURL / _NAME / _PORT, et pour les images 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. AIMSIGHT_S3_URL / _ACCESS_KEY / _SECRET_KEY / _BUCKET.
""" """
import argparse import argparse
@@ -35,16 +38,9 @@ import time
from datetime import datetime, timedelta, timezone from datetime import datetime, timedelta, timezone
from pathlib import Path from pathlib import Path
sys.path.insert(0, os.getcwd()) # racine de l'appli : le paquet `app`
import pandas as pd import pandas as pd
from sqlalchemy import create_engine, func, funcfilter from sqlalchemy import create_engine, text
from sqlalchemy.engine import URL 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 UTC = timezone.utc
STATIONS = Path(__file__).resolve().parent / "stations.txt" # les stations suivies, une par ligne 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"] 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 TYPES = {"images": "OPTICAL_SHIFT-IRON", "images_diff": "OPTICAL_SHIFT-DIFF"} # dossier -> type de mesure
# --- constantes de l'appli (app/datapoints.py, app/aggregates.py) ---
class ReadOnlyDB: QUALITY = ["peak", "flux", "sharpness", "fwhm", "dominance", "snr"]
"""Le strict nécessaire à build_advanced_frame, à camera et à get_measurement_payload (les fonctions de CAM_SIGNALS = ["pan", "tilt", "scale", "rotation", "sigma0"]
DatabaseEngine).""" DEFAULT_ERROR_THRESHOLD = 0.7
get_sensor_state_aggregate = DatabaseEngine.get_sensor_state_aggregate DATATYPES = ["x", "y", "error", "corr_x", "corr_y", "reproj_err", "inlier", "sigma0"]
get_shifts_aggregate = DatabaseEngine.get_shifts_aggregate PROPERTIES = ["x", "y", "pattern_type", "sensor_name", "error_threshold"]
get_common_state_aggregate = DatabaseEngine.get_common_state_aggregate COLUMNS = ["time_utc", "sensor_name", "x", "y", "error_value", "error_threshold", "relative_x", "relative_y", "corr_x",
get_measurement_payload = DatabaseEngine.get_measurement_payload "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",
def __init__(self, engine, session, s3): "inlier", "sigma0"] + QUALITY
self._session, self.s3client, self.aggregates = session, s3, AggregateEngine(engine) # 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): def raison(e):
@@ -72,11 +70,16 @@ def raison(e):
return f"{type(e).__name__}: {(str(e).splitlines() or [''])[0][:300]}" 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*.""" """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"))] 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): 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")} for p in (dossier / "displacement").glob(f"{dossier.name}_advanced_*.csv")}
if not jours: if not jours:
return [(demain - timedelta(days=JOURS_NOUVELLE + 1), fin, True)] 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) premier, dernier = min(jours), max(jours)
trous = [premier + timedelta(days=k) for k in range((dernier - premier).days) 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)] 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 """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 à 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 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.""" 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) noms = sorted(conn.execute(text("SELECT DISTINCT dt.name FROM datatype dt JOIN metric_series se "
.filter(MetricSeries.system_id == system.id).distinct()}) "ON se.datatype_id = dt.id WHERE se.system_id = :s"), {"s": system_id}).scalars())
session.rollback() conn.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): for k in range((fin - debut).days):
a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC)
paths = {n: out / station / "metrics" 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()): if not remplacer and all(p.exists() for p in paths.values()):
continue continue
t0 = time.time() 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: 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 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") print(f"{station} {a:%Y-%m-%d} métriques : échec ({raison(e)}), à relancer")
continue continue
finally:
conn.rollback()
df["heure"] = pd.to_datetime(df["heure"], utc=True) 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 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 # 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") 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 """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) : une ligne par mesure de la caméra (toutes les 15 min à NORDEND, min = max) : ce que trace le visualiseur
ce que trace le visualiseur (fetch_cam_movements_frame, app/datapoints.py), sans son except, qui rendrait vide un (fetch_cam_movements_frame), sans son except, qui rendrait vide un jour en échec au lieu de le laisser à relancer."""
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}, "
df = db.get_shifts_aggregate(unit, f"cam_movements_{AGGREGATE_FALLBACK_RESOLUTION}", a, b) f"max_val(sc.{s}_pct) AS max_{s}" for s in CAM_SIGNALS)
return df.reset_index().drop(columns="sensor_id", errors="ignore") # sensor_id : l'id interne de l'unité 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).""" """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): for k in range((fin - debut).days):
a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) 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" path = out / station / dossier / f"{station}_{nom}_{a:%Y%m%d}.csv"
if path.exists() and not remplacer: if path.exists() and not remplacer:
continue continue
t0 = time.time() t0 = time.time()
try: 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 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") print(f"{station} {a:%Y-%m-%d} {nom} : échec ({raison(e)}), à relancer")
continue continue
finally: finally:
db._session.rollback() # ferme la transaction de lecture conn.rollback() # ferme la transaction de lecture
if "sensor_name" in df: if "sensor_name" in df:
df = df.drop_duplicates(["sensor_name", "time_utc"]) df = df.drop_duplicates(["sensor_name", "time_utc"])
path.parent.mkdir(parents=True, exist_ok=True) 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}") 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): def pomper_images(conn, s3, unit, station, debut, fin, dossier, every, out):
mt = session.query(MeasurementType).filter_by(name=TYPES[dossier]).one_or_none() mt = conn.execute(text("SELECT id, extension FROM measurement_type WHERE name = :n"), {"n": TYPES[dossier]}).first()
if mt is None: if mt is None:
print(f"{station} : type {TYPES[dossier]} inconnu") print(f"{station} : type {TYPES[dossier]} inconnu")
return return
client, bucket_s3 = s3
for k in range((fin - debut).days): for k in range((fin - debut).days):
a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) 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, mesures = conn.execute(text(
Measurement.time_utc < a + timedelta(days=1)).order_by(Measurement.time_utc) "SELECT id, time_utc, measurement_uuid FROM measurement WHERE acquisition_unit_id = :au "
mesures = q.all() "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 seen, n, octets, sans_uuid, absentes = set(), 0, 0, 0, 0
for m in mesures: for m in mesures:
# measurement_uuid vide : l'image n'est jamais arrivée sur S3 (envoi en plusieurs parties inachevé) ; # 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 seen.add(bucket) # même déjà là : sinon la relance prendrait l'image suivante de la tranche
if path.exists(): if path.exists():
continue 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: if data:
path.parent.mkdir(parents=True, exist_ok=True) path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(data) path.write_bytes(data)
n, octets = n + 1, octets + len(data) n, octets = n + 1, octets + len(data)
else: else:
absentes += 1 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 # 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 " 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)") 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"]) database=os.environ["AIMSIGHT_DATABASE_NAME"])
engine = create_engine(url, connect_args={ engine = create_engine(url, connect_args={
"options": f"-c timezone=utc -c default_transaction_read_only=on -c statement_timeout={a.delai}s"}) "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", ""), s3 = None
os.environ.get("AIMSIGHT_S3_SECRET_KEY", ""), if a.images or a.diff:
os.environ.get("AIMSIGHT_S3_BUCKET", "measurements-assets")) if (a.images or a.diff) else None 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: try:
with Session(engine) as session: with engine.connect() as conn:
db = ReadOnlyDB(engine, session, s3)
for station in stations: for station in stations:
system = session.query(System).filter_by(serial_number=station).one_or_none() system_id = conn.execute(text("SELECT id FROM system WHERE serial_number = :s"), {"s": station}).scalar()
if system is None: if system_id is None:
print(f"{station} : système inconnu") print(f"{station} : système inconnu")
continue continue
plages = [(du, fin, False)] if du else plages_suivi(a.out / station, fin, demain) 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: for debut, fin_plage, remplacer in plages:
print(f"{station} : du {debut} au {fin_plage - timedelta(days=1)} inclus" print(f"{station} : du {debut} au {fin_plage - timedelta(days=1)} inclus"
+ ("" if remplacer else ", jours manquants seulement")) + ("" 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: if unit is None:
print(f"{station} : pas d'unité d'acquisition reconnue, ni déplacements, ni caméra, ni images") print(f"{station} : pas d'unité d'acquisition reconnue, ni déplacements, ni caméra, ni images")
continue 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")): for flag, dossier in ((a.images, "images"), (a.diff, "images_diff")):
if flag: 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: finally:
engine.dispose() engine.dispose()
+25
View File
@@ -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"
+5 -3
View File
@@ -1,17 +1,19 @@
# Pomper les données des stations # Pomper les données des stations
Dans le terminal du dev container de l'appli (VS Code sur `~/monitoring-dashboard`, « Reopen in Container »), mettre à jour les stations suivies (`extraction/stations.txt`) jusqu'à maintenant : Automatique chaque nuit par le Planificateur de tâches de Windows (D-146, installation : `extraction/README.md`). À la main, dans un terminal WSL, mettre à jour les stations suivies (`extraction/stations.txt`) jusqu'à maintenant :
```bash ```bash
(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --images --delai 300); chown -R 1000:1000 /workspaces/Support-Agent/data extraction/pomper.sh
``` ```
- Ce qu'il a fait : `out/pompage.log`.
- Chaque station comble ses jours manquants, puis repart de son dernier jour pompé (repompé, il était peut-être incomplet) ; une station absente de `data/` reçoit les 30 derniers jours. Ajouter une station : une ligne dans `extraction/stations.txt`. - Chaque station comble ses jours manquants, puis repart de son dernier jour pompé (repompé, il était peut-être incomplet) ; une station absente de `data/` reçoit les 30 derniers jours. Ajouter une station : une ligne dans `extraction/stations.txt`.
Une plage choisie (historique, jour en échec) : Une plage choisie (historique, jour en échec) :
```bash ```bash
(set -a && . ./.env && set +a && python3 /workspaces/Support-Agent/extraction/pomper.py --du <DEBUT> --au <FIN> --images --delai 300 <SERIE>); chown -R 1000:1000 /workspaces/Support-Agent/data extraction/pomper.sh --du <DEBUT> --au <FIN> --images --delai 300 <SERIE>
``` ```
- `<SERIE>` : numéro de série du système, celui de l'URL de la page System (`/explore/system/<SERIE>`), par exemple `NORDEND` ; plusieurs stations : `<SERIE1> <SERIE2>`. - `<SERIE>` : numéro de série du système, celui de l'URL de la page System (`/explore/system/<SERIE>`), par exemple `NORDEND` ; plusieurs stations : `<SERIE1> <SERIE2>`.