diff --git a/.gitignore b/.gitignore index d114bf9..a870e6b 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ app/web/node_modules/ app/web/dist/ labeling/auto/analyses/*/travail/ .env +/out/ diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 90103d4..8187d46 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -5,9 +5,40 @@ "label": "Run app", "detail": "Monte detectors, prépare .venv et le front au besoin, puis lance le serveur sur http://127.0.0.1:8770", "type": "shell", - "command": "{ [ -e detectors/.git ] || { git submodule update --init && git -C detectors checkout -q -B main; }; } && { [ -d .venv ] || { python3 -m venv .venv && .venv/bin/pip install -q fastapi uvicorn markdown plotly matplotlib; }; } && (cd app/web && { [ -d node_modules ] || npm install; } && npm run build) && .venv/bin/python app/serveur/serveur.py", + "command": "{ [ -e detectors/.git ] || { git submodule update --init && git -C detectors checkout -q -B main; }; } && { [ -d .venv ] || { python3 -m venv .venv && .venv/bin/pip install -q -r app/requirements.txt; }; } && (cd app/web && { [ -d node_modules ] || npm install; } && npm run build) && .venv/bin/python app/serveur/serveur.py", "isBackground": true, "problemMatcher": [] + }, + { + "label": "pomper", + "detail": "Met à jour les stations suivies (extraction/stations.txt), images comprises ; extraction/README.md", + "type": "shell", + "command": "extraction/pomper.sh", + "problemMatcher": [] + }, + { + "label": "pomper une plage", + "detail": "Pompe une plage de jours UTC (--au exclu) pour une ou plusieurs stations, images comprises", + "type": "shell", + "command": "extraction/pomper.sh --du ${input:du} --au ${input:au} --images --delai 300 ${input:stations}", + "problemMatcher": [] + } + ], + "inputs": [ + { + "id": "du", + "type": "promptString", + "description": "Premier jour UTC (AAAA-MM-JJ) ; 3 jours avant la période voulue, pour l'historique des détecteurs" + }, + { + "id": "au", + "type": "promptString", + "description": "Dernier jour UTC, exclu (AAAA-MM-JJ)" + }, + { + "id": "stations", + "type": "promptString", + "description": "Numéros de série des stations, séparés par des espaces (ex. NORDEND)" } ] } diff --git a/CLAUDE.md b/CLAUDE.md index 532767b..b4ca1f6 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,16 +1,19 @@ # CLAUDE.md -Diagnostic-app : la web app de diagnostic AIMsight et les agents qu'elle lance par `claude -p` (`README.md`). Une caméra suit des cibles sur un ouvrage ; les détecteurs (`detectors/`, un sous-module : le dépôt detectors) lisent les séries de déplacement des stations (`data//`, hors de git) et signalent les moments où il ne faut pas se fier aux courbes (pluie, buée, toile d'araignée, turbulence…) ou un vrai mouvement. +Diagnostic-app : la web app de diagnostic AIMsight et les agents qu'elle lance par `claude -p` (`README.md`). Une caméra suit des cibles sur un ouvrage ; les détecteurs (`detectors/`, un sous-module : le dépôt detectors) lisent les séries de déplacement des stations (`data//`, hors de git, rempli par le pompage `extraction/`) et signalent les moments où il ne faut pas se fier aux courbes (pluie, buée, toile d'araignée, turbulence…) ou un vrai mouvement. - **Les processus** : l'onglet Analysis lance l'`analyste` sur une plage (étiquettes et rapport dans `labeling/auto/analyses/__/`, versées dans `labeling/auto/.jsonl`) ; « Optimiser les détecteurs » lance `/detectors:wf-improve` sur la plage de l'analyse (le plugin du sous-module `detectors/`, `claude --plugin-dir detectors` ; la requête dans `app/serveur/analyse.py`, son bilan dans `/detectors//summary.md`), qui commite dans `detectors/`, puis le `tool-builder`, qui commite les outils ici. - **La vérité** : les étiquettes de `labeling/auto/` ; le savoir du labeling est dans `labeling/` (règles, familles, carte, connaissances). -- **Le benchmark** : `python3 detectors/skills/wf-improve/scripts/regression.py --labels labeling/auto --data data` ; le score d'une plage : `python3 detectors/skills/wf-improve/scripts/score.py data/ --labels labeling/auto/.jsonl --from AAAA-MM-JJ --to AAAA-MM-JJ` (`--to` exclu). Le contrat entre l'app et les détecteurs : `detectors/CLAUDE.md`. -- **Vérifier un changement de l'app** : `.venv/bin/python app/serveur/check.py`, puis `cd app/web && npm run build` et lancer le serveur. +- **Les détecteurs** : le contrat entre l'app et eux est dans `detectors/CLAUDE.md` (`categories.events`, la requête de `/detectors:wf-improve`, les CLI `--from/--to`) ; un renommage là-bas demande le changement ici. `agent-tools/donnees.py` et `detectors/scripts/data.py` lisent les mêmes mesures : une correction de lecture dans l'un se reporte dans l'autre. Après un commit dans `detectors/` : `git -C detectors push`, puis `git commit -m "..." -- detectors`. +- **Le benchmark** : `python3 detectors/skills/wf-improve/scripts/regression.py --labels labeling/auto --data data` (~3 min) ; le score d'une plage : `python3 detectors/skills/wf-improve/scripts/score.py data/ --labels labeling/auto/.jsonl --from AAAA-MM-JJ --to AAAA-MM-JJ` (`--to` exclu). +- **Le pompage** : `extraction/pomper.sh` (tâches VS Code **pomper**, **pomper une plage**), en lecture seule sur la plateforme ; mode d'emploi `extraction/README.md`. Claude peut le lancer sur de petites plages ; une longue plage ou un historique, hors des heures chargées. +- **Vérifier un changement de l'app** : `.venv/bin/python app/serveur/check.py`, puis `cd app/web && npm run build` et lancer le serveur. Les étiquettes : `python3 labeling/controle.py` (les 18 étiquettes versées par l'app n'ont pas encore `revue`, qu'elle exige : 18 erreurs attendues). Règles : - Toute heure est en UTC. - Bibliothèque standard pour les détecteurs et les outils de lecture ; matplotlib par `.venv/bin/python`, pour les figures seulement. - Pas de règle propre à une station, une cible ou une date dans les détecteurs. -- Lecture seule sur `data/` ; ne jamais recopier les identifiants des métriques (`SIM_CCID`, `ip*`). +- Lecture seule sur `data/`, sauf le pompage ; ne jamais recopier les identifiants des métriques (`SIM_CCID`, `ip*`). +- Ne jamais lire `.env` (les identifiants de la plateforme). - Commits par chemin, jamais `git add -A` : une autre session peut travailler dans ce dépôt. - Langue : documents et échanges en français ; ce qui va au client en anglais. diff --git a/README.md b/README.md index 049f89e..ee8370e 100644 --- a/README.md +++ b/README.md @@ -11,24 +11,46 @@ La web app de diagnostic AIMsight : la page Data (courbes, images de la caméra, - `.claude/` : les agents de l'app, `analyste` et `tool-builder`, et le skill `lire-les-donnees` (le mode d'emploi des outils de lecture). - `agent-tools/` : les outils de lecture ; `donnees.py`, la lecture commune, sert aussi à l'app. - `labeling/` : le savoir du labeling (`regles-d-etiquetage.md`, `familles.md`, `carte-des-etiquettes.md`, `connaissances/`), les étiquettes (`auto/.jsonl`, la vérité du benchmark ; `manual/`), les analyses de l'app (`auto/analyses/`), et `controle.py`, `ids.py`. -- `detectors/` : le dépôt **detectors**, en sous-module : les détecteurs (`scripts/`) et le plugin Claude Code qui les améliore (`/detectors:wf-improve`). L'app lui donne tout à chaque séance (plage, étiquettes, vérité de référence, familles, dossier de sortie : `/detectors//`) ; la séance commite dans `detectors/`, sur sa branche `main`. Ensuite : `git -C detectors push`, puis ici `git commit -m "..." -- detectors` pour que le dépôt pointe la nouvelle version. Mettre à jour les détecteurs : `git -C detectors pull`. +- `detectors/` : le dépôt **detectors**, en sous-module (voir plus bas). +- `extraction/` : le pompage, qui remplit `data/` depuis la plateforme AIMsight, en lecture seule ; mode d'emploi dans `extraction/README.md`. - `data/` : les données des stations, **hors de git**, un dossier par station (`displacement/`, `metrics/`, `camera/`, `images/`). +## Les détecteurs (`detectors/`) + +Le dépôt detectors : un détecteur par famille d'étiquettes (`scripts/`), `scripts/categories.py` qui les lance et range leurs épisodes en événements, et le plugin Claude Code qui les améliore (`/detectors:wf-improve`, avec `skills/wf-improve/scripts/score.py` et `regression.py`). Son contrat avec l'app est dans `detectors/CLAUDE.md` ; ici : + +- la page Data montre les événements de `categories.events`, calculés sur les mesures lues par `agent-tools/donnees.py` (les mêmes que celles de `detectors/scripts/data.py`) ; +- « Optimiser les détecteurs » donne à `/detectors:wf-improve` la plage, les étiquettes (`labeling/auto/.jsonl`), la vérité de référence (`labeling/auto`, `data`), les familles (`labeling/familles.md`), le rapport de l'analyse et le dossier de sortie, `/detectors//` (la requête : `app/serveur/analyse.py`) ; +- la séance commite dans `detectors/`, sur sa branche `main`, sans pousser. Ensuite : `git -C detectors push`, puis ici `git commit -m "..." -- detectors`, pour que ce dépôt pointe la nouvelle version. + +Mettre à jour les détecteurs : `git -C detectors pull`, puis `git commit -m "..." -- detectors`. + ## Installer et lancer -La tâche VS Code **Run app** fait tout : monte `detectors` la première fois (sur sa branche `main`), crée `.venv` et construit le front s'ils manquent, lance le serveur. Il faut seulement les données : - -```bash -ln -s /data data # ou un dossier data/ rempli par le pompage -``` +La tâche VS Code **Run app** fait tout : monte `detectors` la première fois (sur sa branche `main`), crée `.venv` et construit le front s'ils manquent, lance le serveur. Il faut seulement les données : les pomper (ci-dessous), ou un lien vers un `data/` existant (`ln -s /data data`). À la main : ```bash git submodule update --init && git -C detectors checkout -B main -python3 -m venv .venv && .venv/bin/pip install fastapi uvicorn markdown plotly matplotlib +python3 -m venv .venv && .venv/bin/pip install -r app/requirements.txt cd app/web && npm install && npm run build && cd ../.. .venv/bin/python app/serveur/serveur.py ``` -La page s'ouvre sur `http://127.0.0.1:8770`. `claude` (Claude Code, connecté) doit être sur le `PATH` pour l'onglet Analysis. Vérifications : `.venv/bin/python app/serveur/check.py`. Benchmark des détecteurs : `python3 detectors/skills/wf-improve/scripts/regression.py --labels labeling/auto --data data` (~3 min). +La page s'ouvre sur `http://127.0.0.1:8770`. `claude` (Claude Code, connecté) doit être sur le `PATH` pour l'onglet Analysis. + +## Pomper les données + +Il faut un `.env` à la racine (identifiants de la base et du S3 de la plateforme, hors de git ; les noms des variables dans `extraction/README.md`), et `uv`. Puis, tâches VS Code : + +- **pomper** : met à jour les stations suivies (`extraction/stations.txt`) jusqu'à maintenant, images comprises (`extraction/pomper.sh`) ; +- **pomper une plage** : une plage de jours UTC (`--au` exclu) pour une ou plusieurs stations (`extraction/pomper.sh --du AAAA-MM-JJ --au AAAA-MM-JJ --images --delai 300 `). + +La sortie s'ajoute à `out/pompage.log`. Le pompage de chaque nuit (Planificateur de tâches de Windows) : `extraction/README.md`. + +## Vérifier + +- l'app : `.venv/bin/python app/serveur/check.py` ; +- les étiquettes : `python3 labeling/controle.py` (les 18 étiquettes versées par l'app n'ont pas encore `revue`, qu'elle exige : 18 erreurs attendues) ; +- les détecteurs (benchmark, ~3 min) : `python3 detectors/skills/wf-improve/scripts/regression.py --labels labeling/auto --data data`. diff --git a/app/README.md b/app/README.md index b82bedc..47e6d66 100644 --- a/app/README.md +++ b/app/README.md @@ -1,25 +1,35 @@ # La web app AIMsight -L'outil du diagnostic manuel : la page Data (la page Images, retirée, vit dans Data ; la page Support est retirée). +L'outil du diagnostic manuel : une seule page, **Data**. -- **Data** (D-139) : le visualiseur de courbes, et l'étiquetage de `labeling/labeling.py` : un plot au départ (déplacements, caméra, qualité, métriques système), « Ajouter un plot » pour en voir plusieurs, alignés sur le temps, la croix pour en enlever un, un clic sur une courbe cale les images sur l'image la plus proche de son instant ; sous eux le choix des étiquettes, Detectors (les événements des détecteurs du journal, `detectors/categories.py`, en lecture seule, D-140), LLM (`labeling/auto/`, en lecture seule) ou Analysis (les mêmes étiquettes de `labeling/auto/`, à modifier, supprimer), et leur barre ; avec Detectors et LLM, y glisser zoome dans le temps ; avec Analysis, y glisser sélectionne une plage, puis des indices facultatifs, « Analyser la plage » : `serveur/analyse.py` lance l'analyste par `claude -p` (non interactif) sur la plage ; il écrit dans `labeling/auto/analyses/__/` ses étiquettes et un rapport de diagnostic (`rapport.md`, ses figures ; son travail et le journal de claude dans `travail/`, hors de git) ; la page suit son avancement, puis montre le rapport, et le serveur verse ses étiquettes dans `labeling/auto/.jsonl` (champ `analyse`, sans `revue` : à relire par `/review-auto-labels`) ; « Voir le rapport » sur une étiquette ainsi faite le rouvre. La barre latérale range toutes les analyses de `labeling/auto/analyses/` en dossiers, un par station (ouvert d'office s'il en a une en cours), et dedans une analyse par plage, la plus récente en tête, avec son état ; un clic ouvre Data sur elle. Une analyse s'arrête avec le serveur (« interrompue ») : sa session gardée, « continue » dans le champ de message la reprend. Sur une analyse finie, « Optimiser les détecteurs » lance `/detectors:wf-improve` sur la plage de l'analyse, par `claude -p` (D-148) : les détecteurs, puis les outils de lecture, améliorés depuis l'analyse, commités sur `main` (les détecteurs dans `detectors/`) ; la page suit le fil de la séance (`travail/optimisation.jsonl`), puis montre son bilan (`/detectors//summary.md`, puis `/outils.md`) sous le rapport. Une optimisation à la fois ; pendant, ni analyse ni message à l'analyste ; une optimisation coupée par l'arrêt du serveur se relance par le bouton. Un clic met une étiquette en évidence sur les plots et la barre, cale les images sur son début, et l'ouvre (avec Analysis : bornes, famille, texte, Enregistrer, Supprimer) ; un clic ailleurs sur la barre la referme. Les zones des étiquettes sur les plots sont à peine visibles (opacité 0,05, 0,07 en sombre). Écrit dans `labeling/auto/.jsonl` ; `labeling/manual/` ne s'écrit plus que par `labeling/labeling.py`. À droite, les images de la caméra, comme `view/view.py` (glisseur, ◀ ▶ et flèches du clavier ; molette pour zoomer, glisser pour se déplacer, double clic pour l'image entière ; case Noms ; une plage sur la barre sous le glisseur dessine la flèche de déplacement de chaque capteur), sur la même station et la même plage (D-140) ; une flèche en haut à gauche de l'image l'agrandit et pousse les plots vers la gauche (les colonnes glissent, les plots se recalent à la fin du glissement), la flèche inverse la ramène. Les événements des détecteurs ne portent que leur famille dans la barre ; la bulle donne leurs cibles ; au clic, leurs dates, leurs capteurs (cibles et références), le message (la première phrase du journal) et l'action (la colonne « Pour le client » de `labeling/familles.md`, précisée par sorte, `station.ACTION_SORTE`). Sous l'image, les paramètres du diagnostic : « Focus on event curves » (un événement ouvert, les plots ne montrent que ses capteurs : ceux des détecteurs, ou ceux que nomme le texte d'une étiquette), les familles montrées (filtre immédiat de la page) et, pour Detectors seulement, les cibles considérées, les autres écartées avant les détecteurs (« Relancer les détecteurs », paramètre `cibles` de `/api/detecteurs`). Sans dates dans l'adresse, la sélection prend les 5 derniers jours UTC, aujourd'hui compris. Detectors est la source par défaut. +## La page Data -Data garde la station et la plage (UTC, Au exclue) dans l'adresse : `#/data?station=NIEDERHORN&du=2026-09-25&au=2026-10-08`. +- **Les plots** : un au départ (déplacements, caméra, qualité d'image, métriques système), « Ajouter un plot » pour en voir plusieurs, alignés sur le temps, la croix pour en enlever un ; un clic sur une courbe cale les images sur l'image la plus proche de cet instant. Les zones des étiquettes y sont à peine visibles (opacité 0,05, 0,07 en sombre). +- **Les étiquettes**, sous les plots, et leur barre, selon la source choisie : + - **Detectors** (par défaut) : les événements des détecteurs (`detectors/scripts/categories.py`, `events`), en lecture seule. La barre ne porte que leur famille, la bulle leurs cibles ; au clic : leurs dates, leurs capteurs (cibles et références), le message (la première phrase du texte de l'événement, `categories.sentence`) et l'action (la colonne « Pour le client » de `labeling/familles.md`, précisée par sorte, `station.ACTION_SORTE`) ; + - **LLM** : `labeling/auto/.jsonl`, en lecture seule ; + - **Analysis** : les mêmes étiquettes, à modifier ou supprimer ; écrit dans `labeling/auto/.jsonl`. + + Avec Detectors et LLM, glisser sur la barre zoome dans le temps ; avec Analysis, cela sélectionne une plage à analyser. Un clic met une étiquette en évidence sur les plots et la barre, cale les images sur son début et l'ouvre (avec Analysis : bornes, famille, texte, Enregistrer, Supprimer) ; un clic ailleurs sur la barre la referme. La page ne montre pas `labeling/manual/`. +- **Les images de la caméra**, à droite, sur la même station et la même plage : glisseur, ◀ ▶ et flèches du clavier ; molette pour zoomer, glisser pour se déplacer, double clic pour l'image entière ; case Noms ; une plage sur la barre sous le glisseur dessine la flèche de déplacement de chaque capteur. Une flèche en haut à gauche agrandit l'image et pousse les plots vers la gauche ; la flèche inverse la ramène. +- **Les paramètres du diagnostic**, sous l'image : « Focus on event curves » (un événement ouvert, les plots ne montrent que ses capteurs : ceux des détecteurs, ou ceux que nomme le texte d'une étiquette), les familles montrées et, pour Detectors seulement, les cibles considérées, les autres écartées avant les détecteurs (« Relancer les détecteurs », paramètre `cibles` de `/api/detecteurs`). + +L'adresse garde la station et la plage (UTC, `au` exclu) : `#/data?station=NIEDERHORN&du=2026-09-25&au=2026-10-08` ; sans dates, les 5 derniers jours UTC, aujourd'hui compris. + +## L'onglet Analysis + +- **Analyser la plage** : une plage sélectionnée, des indices facultatifs, puis `serveur/analyse.py` lance l'analyste par `claude -p` (non interactif). Il écrit dans `labeling/auto/analyses/__/` ses étiquettes et un rapport de diagnostic (`rapport.md` et ses figures ; son travail et le journal de claude dans `travail/`, hors de git). La page suit son avancement, puis montre le rapport ; le serveur verse ses étiquettes dans `labeling/auto/.jsonl` (champ `analyse`). « Voir le rapport » sur une telle étiquette le rouvre. +- **La barre latérale** range les analyses de `labeling/auto/analyses/` en dossiers, un par station (ouvert d'office s'il en a une en cours), et dedans une analyse par plage, la plus récente en tête, avec son état ; un clic ouvre Data sur elle. +- **Les messages** : après le rapport, l'utilisateur écrit à l'analyste, la même session reprend (`--resume`). Une analyse s'arrête avec le serveur (« interrompue ») ; « continue » dans le champ de message la reprend. +- **Optimiser les détecteurs**, sur une analyse finie : `/detectors:wf-improve` sur la plage de l'analyse (`--plugin-dir detectors`), puis le `tool-builder` ; les détecteurs commités dans `detectors/`, les outils de lecture ici, sur `main`. La page suit le fil de la séance (`travail/optimisation.jsonl`), puis montre son bilan sous le rapport (`/detectors//summary.md`, puis `/outils.md`). Une optimisation à la fois ; pendant, ni analyse ni message à l'analyste ; une optimisation coupée par l'arrêt du serveur se relance par le bouton. Les événements des détecteurs sont gardés en mémoire jusqu'à la fin d'une optimisation : après un `/detectors:wf-improve` lancé hors de l'app, relancer le serveur. ## Lancer -En une commande : la tâche VS Code `run app` (`.vscode/tasks.json` : construit le front, puis lance le serveur). Ou à la main : - -Une fois, et après chaque changement de la page : construire le front (Node 22). +La tâche VS Code **Run app** (`.vscode/tasks.json`), ou à la main (Node 22 pour le front) : ```bash -cd app/web && npm install && npm run build -``` - -Puis le serveur, avec l'environnement Python du dépôt (`.venv`, voir le README à la racine) : - -```bash -.venv/bin/python app/serveur/serveur.py +cd app/web && npm install && npm run build # une fois, et après chaque changement de la page +.venv/bin/python app/serveur/serveur.py # .venv : voir le README à la racine ``` La page s'ouvre sur `http://127.0.0.1:8770`. Réglages par variables : `AIMSIGHT_DATA` (données, défaut `data/`), `AIMSIGHT_LABELS` (étiquettes, défaut `labeling/`), `AIMSIGHT_PORT` (8770). Pour travailler sur la page : `npm run dev` dans `app/web/` (http://localhost:5173), le serveur Python lancé à côté. @@ -27,20 +37,9 @@ La page s'ouvre sur `http://127.0.0.1:8770`. Réglages par variables : `AIMSIGHT ## Les dossiers - `serveur/serveur.py` : FastAPI ; sert la page construite et l'API sous `/api` (stations, images, courbes, détecteurs, étiquettes, analyses) ; ne répond qu'aux pages du poste (Host local, JSON déclaré). -- `serveur/station.py` : les données de la page Data ; lecture seule sur `data/`, écrit seulement dans `labeling/{auto,manual}/`. -- `serveur/analyse.py` : l'onglet Analysis ; lance `claude` (Claude Code, connecté) avec l'agent `analyste`, outils Read, Write, Bash autorisés sans demande ; et l'optimisation, `/detectors:wf-improve` sur la plage de l'analyse (`--plugin-dir detectors`, outils Read, Write, Edit, Bash, Agent) puis l'agent `tool-builder` (Read, Write, Edit, Bash), autorisés sans demande. +- `serveur/station.py` : les données de la page Data ; lecture seule sur `data/` (par `agent-tools/donnees.py`), écrit seulement dans `labeling/{auto,manual}/`. +- `serveur/analyse.py` : l'onglet Analysis ; lance `claude` avec l'agent `analyste` (Read, Write, Bash autorisés sans demande) ; et l'optimisation, `/detectors:wf-improve` (Read, Write, Edit, Bash, Agent) puis l'agent `tool-builder` (Read, Write, Edit, Bash). - `serveur/check.py` : vérifications, sans appel à claude : `.venv/bin/python app/serveur/check.py`. -- `web/` : React (Vite) et Mantine ; `src/App.jsx` (en-tête, barre latérale, adresse), `src/pages/` (une page par fichier), `src/commun.jsx` (requêtes, cartes, sélecteur), `src/main.jsx` (thème). Plotly, habillé aux couleurs de Mantine (D-139), ne se charge qu'avec Data. `dist/` et `node_modules/` hors de git. +- `web/` : React (Vite) et Mantine ; `src/App.jsx` (en-tête, barre latérale, adresse), `src/pages/Data.jsx` (la page), `src/pages/Images.jsx` (les images, dans Data), `src/commun.jsx` (requêtes, cartes, sélecteur), `src/main.jsx` (thème). Plotly, habillé aux couleurs de Mantine, ne se charge qu'avec Data. `dist/` et `node_modules/` hors de git. -## Copies - -Le calcul de la page Data reprend des outils du dépôt Support-Agent ; ce qui en est copié dans `serveur/station.py` vieillit avec eux. - -| Source | Copie | Commit | Date | Adaptation | -|---|---|---|---|---| -| `view/view.py` : `page()` (images, corr à l'heure de chaque image) | `images()` | 6e9f69a | 2026-11-05 | rend du JSON, pas une page | -| `labeling/labeling.py` : `metriques()`, `plots()`, `ajouter()`, `modifier()`, `supprimer()`, `remplace()` | `metriques()`, `courbes()`, et les fonctions des étiquettes | 6e9f69a | 2026-11-05 | rend du JSON ; métriques lues sans `common.stations` | -| `detectors-view/detecteurs.py` : `positions()`, `references()`, `COULEURS`, `POSE`, `MARGE_PX` | idem | 6e9f69a | 2026-11-05 | aucune | -| `labeling/ids.py` : `attribuer()`, `en_tete()` | `attribuer()` | 6e9f69a | 2026-11-05 | sans `retires` (inutile à l'ajout) | - -La lecture des données est celle des agents, `agent-tools/donnees.py` ; les événements des détecteurs, ceux du journal, `detectors/scripts/categories.py` (`events`), lus tels quels (pas une copie : la page montre les détecteurs du jour ; il garde leurs résultats, et les oublie à la fin d'une optimisation ; relancer le serveur après un `/detectors:wf-improve` lancé hors de l'app). +Le calcul de `serveur/station.py` (images, courbes, étiquettes) vient d'outils du dépôt Support-Agent, copiés le 2026-11-05 (commit 6e9f69a) ; il évolue désormais ici. diff --git a/app/requirements.txt b/app/requirements.txt index 3494b8e..0af8063 100644 --- a/app/requirements.txt +++ b/app/requirements.txt @@ -1,3 +1,5 @@ fastapi uvicorn markdown +matplotlib +pillow diff --git a/app/serveur/serveur.py b/app/serveur/serveur.py index e9aeb7c..d2d0e12 100644 --- a/app/serveur/serveur.py +++ b/app/serveur/serveur.py @@ -1,7 +1,7 @@ """La web app : .venv/bin/python app/serveur/serveur.py → http://127.0.0.1:8770 Le serveur FastAPI sert la page React construite (app/web/dist, `npm run build` dans app/web) et l'API sous /api. -La page Data lit data/ et les étiquettes de labeling/ (station.py) ; son onglet Analysis lance l'étiqueteur, et l'optimisation +La page Data lit data/ et les étiquettes de labeling/ (station.py) ; son onglet Analysis lance l'analyste, et l'optimisation des détecteurs (analyse.py). Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_PORT (port, 8770). """ @@ -100,7 +100,7 @@ def supprimer(corps: dict): return station.supprimer(corps) -# --- l'onglet Analysis de la page Data (analyse.py) : l'étiqueteur lancé par claude -p sur une plage +# --- l'onglet Analysis de la page Data (analyse.py) : l'analyste lancé par claude -p sur une plage @app.post("/api/analyses") def lancer_analyse(corps: dict): diff --git a/app/serveur/station.py b/app/serveur/station.py index 928a6b7..26ccfe5 100644 --- a/app/serveur/station.py +++ b/app/serveur/station.py @@ -1,9 +1,7 @@ """Les données de la page Data : les images d'une station, ses courbes, ses étiquettes. -Repris de view/view.py et labeling/labeling.py (le calcul, pas les pages) ; positions, references, COULEURS, POSE et -attribuer sont copiés de detectors-view/detecteurs.py et labeling/ids.py (app/README.md, « Copies »). La lecture des données est -celle des agents, agent-tools/donnees.py ; les événements des détecteurs, ceux du journal, -detectors/scripts/categories.py (D-140). Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/. +La lecture des données est celle des agents, agent-tools/donnees.py ; les événements des détecteurs, ceux de +detectors/scripts/categories.py (events). Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/. """ import bisect import functools @@ -24,7 +22,7 @@ from categories import events # noqa: E402 DONNEES = Path(os.environ.get("AIMSIGHT_DATA", RACINE / "data")).resolve() ETIQUETTES = Path(os.environ.get("AIMSIGHT_LABELS", RACINE / "labeling")).resolve() -DOSSIERS = ("auto", "manual") # celles de l'étiqueteur (D-105), celles de Marc (D-102) +DOSSIERS = ("auto", "manual") # celles des agents et de la page (D-105), celles de l'expert (D-102) FAMILLES = ("Visibility", "Obstruction", "Thermal displacement", "Displacement", "Target issue", "No data", "None") # D-109 FORMAT = "%Y-%m-%dT%H:%MZ" MARGE_PX = 150 # detecteurs.MARGE_PX : x, y ne sont des positions dans l'image que loin du coin @@ -59,7 +57,7 @@ def bornes(du, au): return donnees.instant(du or "0001-01-01"), donnees.instant(au or "9999-01-01") -# --- detectors-view/detecteurs.py +# --- les positions des capteurs dans l'image def positions(mesures, a, b): """La position médiane de chaque capteur dans l'image sur [a, b) ({} si x, y n'y sont pas des positions).""" @@ -74,7 +72,7 @@ def references(mesures, a, b): return {s for s, ms in mesures.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)} -# --- les images de la page Data (view/view.py) +# --- les images de la page Data def images(station, du, au): """Les images de [du, au), les positions médianes des capteurs, les références, et par capteur entouré son corr_x, @@ -106,7 +104,7 @@ def image(station, nom): return f -# --- la page Data (labeling/labeling.py) +# --- les courbes de la page Data def metriques(d, a, b): """Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}} (une valeur vide : None, le @@ -240,7 +238,7 @@ def action(v): or ACTION_FAMILLE.get(v["category"], "") -# --- les étiquettes (labeling/labeling.py, labeling/ids.py) +# --- les étiquettes def fichier(station, source): if source not in DOSSIERS: @@ -307,7 +305,7 @@ def modifier(corps): del label["id"] if not c: del label["categorie"] - label.pop("revue", None) # changée : à revoir par /review-labels (D-103) + label.pop("revue", None) # changée : plus revue return remplace(corps.get("station"), corps.get("dossier", "manual"), avant, label) diff --git a/app/web/package-lock.json b/app/web/package-lock.json index cec4734..4801443 100644 --- a/app/web/package-lock.json +++ b/app/web/package-lock.json @@ -1,10 +1,10 @@ { - "name": "support-aimsight", + "name": "diagnostic-aimsight", "lockfileVersion": 3, "requires": true, "packages": { "": { - "name": "support-aimsight", + "name": "diagnostic-aimsight", "dependencies": { "@mantine/core": "^9.7.5", "@mantine/hooks": "^9.7.5", diff --git a/app/web/package.json b/app/web/package.json index 943d0e6..6f1903c 100644 --- a/app/web/package.json +++ b/app/web/package.json @@ -1,5 +1,5 @@ { - "name": "support-aimsight", + "name": "diagnostic-aimsight", "private": true, "type": "module", "scripts": { diff --git a/app/web/src/pages/Data.jsx b/app/web/src/pages/Data.jsx index 232082f..665a9cf 100644 --- a/app/web/src/pages/Data.jsx +++ b/app/web/src/pages/Data.jsx @@ -7,7 +7,7 @@ import { IconPlus, IconX } from "@tabler/icons-react"; import { appel, Selecteur } from "../commun.jsx"; import { ImagesDe } from "./Images.jsx"; -// Data, le visualiseur de courbes (et l'étiquetage de labeling/labeling.py) : un plot au départ, d'autres à ajouter ou enlever, +// Data, le visualiseur de courbes et l'étiquetage : un plot au départ, d'autres à ajouter ou enlever, // tous alignés sur le temps ; sous eux les étiquettes : Detectors (les événements du journal), LLM (labeling/auto/, en lecture) // ou Analysis (les mêmes, à modifier, supprimer ; glisser sur la barre sélectionne une plage, que l'analyste diagnostique et // étiquette ; ailleurs, glisser zoome) ; un clic ouvre une diff --git a/app/web/src/pages/Images.jsx b/app/web/src/pages/Images.jsx index 9220f76..38922da 100644 --- a/app/web/src/pages/Images.jsx +++ b/app/web/src/pages/Images.jsx @@ -90,7 +90,7 @@ function Visionneuse({ station, d, compacte, large, basculer, instant }) { ); } -// Le code de view/view.py (PAGE_JS), sur les éléments de la page -> la fonction qui défait ce qu'il a installé +// Le comportement de l'image (zoom, déplacement, flèches), sur les éléments de la page -> la fonction qui défait ce qu'il a installé function installer(r, station, d) { const IM = d.images.map(i => ({ t: i.t, src: `/api/image/${encodeURIComponent(station)}/${encodeURIComponent(i.nom)}` })); const C = d.corr, XY = d.positions; diff --git a/app/web/src/style.css b/app/web/src/style.css index 8d02445..7eb903f 100644 --- a/app/web/src/style.css +++ b/app/web/src/style.css @@ -7,7 +7,7 @@ .message.relai { border-left: 3px solid var(--mantine-color-aimsight-filled); } .rapport { width: 100%; height: 78vh; border: 0; display: block; background: #fff; } -/* La page Images (view/view.py) */ +/* Les images de la caméra (Images.jsx) */ .cadre { position: relative; height: calc(100vh - 420px); min-height: 300px; background: #000; overflow: hidden; cursor: grab; touch-action: none; border-radius: var(--mantine-radius-md) var(--mantine-radius-md) 0 0; } .cadre:active { cursor: grabbing; } diff --git a/extraction/README.md b/extraction/README.md new file mode 100644 index 0000000..ae744d5 --- /dev/null +++ b/extraction/README.md @@ -0,0 +1,51 @@ +# extraction/ : pomper les données de la plateforme (lecture seule) + +`pomper.py` récupère, pour chaque station (numéro de série du système) et chaque jour UTC demandé, dans `data//` : +- les **métriques système** (énergie, disque, 4G, températures…), moyennes horaires, un CSV par métrique et par jour dans `metrics/` ; +- les **déplacements** (export « advanced »), un CSV par jour dans `displacement/` ; +- les **mouvements de la caméra** (`pan`, `tilt`, `scale`, `rotation`, `sigma0`), en médiane et bornes (`median_`, `min_`, `max_`) par minute, aux seuls instants où la caméra a été recalée, un CSV par jour dans `camera/` ; +- 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/`. + +Formats : `labeling/connaissances/colonnes-des-deplacements.md`. + +**Stations suivies** : `stations.txt`, un numéro de série par ligne. Sans station ni dates, le script les met toutes à jour jusqu'à maintenant : chaque station comble d'abord ses jours manquants entre le premier et le dernier jour pompé (sans déplacements, ou sans aucune métrique), puis repart de son dernier jour, repompé (il était peut-être incomplet) ; une station sans dossier dans `data/` reçoit les 30 derniers jours. + +Reprise : avec `--du`, un fichier déjà dans `data//` 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 (sous WSL) + +`pomper.sh` lit les identifiants dans le `.env` à la racine du dépôt (base PostgreSQL et S3 ; 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), 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 (verrou `out/pompage.lock`). Le verrou ne vaut que pour ce dépôt : `data/` étant un lien vers celui de Support-Agent, ne pomper que depuis un seul des deux dépôts. + +Variables du `.env` : `AIMSIGHT_DATABASE_USER`, `_PSWD`, `_TURL`, `_NAME`, `_PORT` ; pour les images, `AIMSIGHT_S3_URL`, `_ACCESS_KEY`, `_SECRET_KEY`, `_BUCKET`. + +1. **Un essai** (1 station, 2 jours, dans un dossier jetable) : `extraction/pomper.sh --du 2026-11-09 --au 2026-11-11 --images --out /tmp/essai-pompage NORDEND` (6 s le 2026-11-12). `lenzspitze_absolu.py` convertit ensuite `data/LENZSPITZE`, pas le dossier `--out` : sans effet si `data/LENZSPITZE` est déjà converti. +2. **Mettre à jour les stations suivies** : `extraction/pomper.sh` (sans argument : `--images --delai 300`), ou la tâche VS Code **pomper**. 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 des détecteurs) : `extraction/pomper.sh --du 2026-10-02 --au 2026-10-26 --images ` (`--au` exclu ; plusieurs stations : ` `). 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/Diagnostic-App/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"`. + +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). + +Sans dépendance à l'appli `monitoring-dashboard` : ses lectures sont recopiées dans `pomper.py`, en SQL (sa docstring dit lesquelles, et de quel commit). Si l'appli change ses lectures, le script ne suit pas : comparer à nouveau des fichiers pompés aux deux. + +## Avec Claude + +Claude peut lancer `pomper.sh` lui-même (accord de l'utilisateur, 2026-11-12) : lecture seule, petites plages ; une longue plage ou un historique, hors des heures chargées. Il ne lit jamais le `.env`. + +## À savoir + +- `` est le numéro de série du **système**, celui de l'URL de la page System (`/explore/system/`) et du début des CSV qu'on y télécharge (`NORDEND_BusVoltage_…` : `NORDEND`) ; pas le nom de l'appareil de la page Explore. +- `data/` est hors de git : un dossier perdu se repompe. +- Un jour en échec par délai dépassé (`QueryCanceled: … statement timeout`) : le relancer seul avec `--delai 300`. La lenteur vient de la base, pas du volume. +- Une heure sans image peut avoir sa mesure : l'image n'est jamais arrivée sur S3 (`measurement_uuid` vide, envoi inachevé). Le script la saute et prend l'image suivante de la tranche s'il y en a une. +- Un jour passé, pompé avant que la station ait fini d'envoyer ses données (coupure, synchronisation en retard), reste incomplet : supprimer ses fichiers dans `data//` et relancer. +- LENZSPITZE : ses exports ont `x` / `y` relatifs et `pattern_type` vide ; `pomper.sh` lance ensuite `lenzspitze_absolu.py` (provisoire ; détail dans `labeling/connaissances/colonnes-des-deplacements.md`). diff --git a/extraction/lenzspitze_absolu.py b/extraction/lenzspitze_absolu.py new file mode 100644 index 0000000..8a08275 --- /dev/null +++ b/extraction/lenzspitze_absolu.py @@ -0,0 +1,49 @@ +"""Provisoire, LENZSPITZE seulement : x / y des exports advanced en position absolue dans l'image, comme sur les autres stations. + +Sur LENZSPITZE, x / y sont relatifs à la position de référence du motif (médianes ~0 px). Ce script réécrit en place +data/LENZSPITZE/displacement/*.csv : + x = x_motif + DX + x_csv, y = y_motif + DY + y_csv, où (x_motif, y_motif) est le centre du motif dans + data/LENZSPITZE/lentzpitze_patterns.json et (DX, DY) le décalage entre le repère du JSON et les images IRON ; + pattern_type, vide dans ces exports, est rempli depuis le JSON. +Les capteurs absents du JSON (1023, 8019) : x / y vidés (position inconnue) ; 8019 reçoit global_ref (il a des reproj_err). +Un fichier dont pattern_type est déjà rempli est laissé tel quel (déjà converti). Un repompage rend les originaux. + +Usage : python3 extraction/lenzspitze_absolu.py +""" +import csv +import glob +import json +import os + +STATION = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "data", "LENZSPITZE") +# Mesuré le 2026-11-04 : médiane (tache − motif du JSON) sur 9 images de nuit du 17.10 au 03.11, 25 à 34 cibles appariées +# chacune, stable à 0,5 px près. Comprend l'écart constant tache − (x, y) déjà vu sur NORDEND (colonnes-des-deplacements.md). +DX, DY = 330.5, 15.8 +TYPE_SANS_MOTIF = {"8019": "global_ref"} # reproj_err et inlier remplis : référence de la compensation + +motifs = {str(v["sensor_name"]): v for v in json.load(open(os.path.join(STATION, "lentzpitze_patterns.json"))).values()} + +for chemin in sorted(glob.glob(os.path.join(STATION, "displacement", "*.csv"))): + with open(chemin, newline="") as f: + lecteur = csv.DictReader(f) + champs, lignes = lecteur.fieldnames, list(lecteur) + if any(r["pattern_type"] for r in lignes): + print(f"{os.path.basename(chemin)} : déjà converti") + continue + for r in lignes: + s = r["sensor_name"].strip() + m = motifs.get(s) + if m is None: + r["x"] = r["y"] = "" + r["pattern_type"] = TYPE_SANS_MOTIF.get(s, "") + continue + r["pattern_type"] = m["pattern_type"] + if r["x"]: + r["x"] = repr(m["x"] + DX + float(r["x"])) + if r["y"]: + r["y"] = repr(m["y"] + DY + float(r["y"])) + with open(chemin, "w", newline="") as f: + w = csv.DictWriter(f, fieldnames=champs) + w.writeheader() + w.writerows(lignes) + print(f"{os.path.basename(chemin)} : {len(lignes)} lignes converties") diff --git a/extraction/pomper.py b/extraction/pomper.py new file mode 100644 index 0000000..e06afc9 --- /dev/null +++ b/extraction/pomper.py @@ -0,0 +1,408 @@ +"""Pompe les métriques système, les déplacements (export « advanced ») et les images de stations de la plateforme +AIMsight, dans le format que lisent l'app, les outils de lecture et les détecteurs. LECTURE SEULE. Essayé le +2026-10-26 (NORDEND, 2 jours) ; autonome depuis le 2026-11-12. + +À lancer par extraction/pomper.sh, sous WSL, depuis n'importe où (voir README.md) : + + extraction/pomper.sh + extraction/pomper.sh --du 2026-08-01 --au 2026-08-08 --images WEISSHORN + +Sans station : celles de `stations.txt`. Sans `--du` : chaque station comble ses jours manquants (déplacements ou +métriques) avant le dernier pompé, puis repart de ce dernier jour, repompé (il était peut-être incomplet), ou des 30 +derniers jours si elle n'en a pas ; sans `--au` : jusqu'à maintenant. + +Sortie (défaut : le `data/` du dépôt, à côté de ce dossier) : + /metrics/___00_00 to _23_00.csv métriques système, par jour + /displacement/_advanced_.csv déplacements, un fichier par jour + /camera/_camera_.csv mouvements de la caméra, par jour + /images/TZ_. images OPTICAL_SHIFT-IRON (--images) + /images_diff/… images différentielles (--diff) +Reprenable : avec `--du`, un fichier déjà écrit n'est pas relu, quelles que soient les dates demandées ; sans `--du`, +les jours de la plage sont remplacés (images exceptées). Jours en UTC, `--au` exclu ; le jour en cours est pompé tel +qu'il est, ses métriques jusqu'à la dernière heure terminée. Pour reprendre un jour, supprimer ses fichiers. + +Sans dépendance à l'appli (~/monitoring-dashboard) : ses lectures sont recopiées ici, en SQL, telles quelles (branche +`explo`, commit 3dce73d du 2026-11-12) : la requête de System.get_metrics (le téléchargement de la page System) ; +build_advanced_frame (app/datapoints.py, ce que tracent l'onglet Advanced et l'export parquet), avec +AcquisitionUnit.get_datapoints et AggregateEngine.get_sensor_aggregate / get_common_aggregate ; les mouvements de la +caméra de fetch_cam_movements_frame (AggregateEngine.get_cam_scalar_aggregate, ce que trace le visualiseur) ; +AcquisitionUnit.measurements et get_measurement_payload (S3). Si l'appli change ses lectures, ce fichier ne suit pas. +Connexion en lecture seule (`default_transaction_read_only`), délai de 60 s par requête (`--delai`). Variables lues +(noms seulement, aucune n'est affichée) : AIMSIGHT_DATABASE_USER / _PSWD / _TURL / _NAME / _PORT, et pour les images +AIMSIGHT_S3_URL / _ACCESS_KEY / _SECRET_KEY / _BUCKET. +""" +import argparse +import os +import sys +import time +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import pandas as pd +from sqlalchemy import create_engine, text +from sqlalchemy.engine import URL + +UTC = timezone.utc +STATIONS = Path(__file__).resolve().parent / "stations.txt" # les stations suivies, une par ligne +JOURS_NOUVELLE = 30 # sans --du, une station sans déplacements pompés : les 30 derniers jours +DB_NAMES = ["AIMSIGHT_DATABASE_USER", "AIMSIGHT_DATABASE_PSWD", "AIMSIGHT_DATABASE_TURL", "AIMSIGHT_DATABASE_NAME"] +TYPES = {"images": "OPTICAL_SHIFT-IRON", "images_diff": "OPTICAL_SHIFT-DIFF"} # dossier -> type de mesure + +# --- constantes de l'appli (app/datapoints.py, app/aggregates.py) --- +QUALITY = ["peak", "flux", "sharpness", "fwhm", "dominance", "snr"] +CAM_SIGNALS = ["pan", "tilt", "scale", "rotation", "sigma0"] +DEFAULT_ERROR_THRESHOLD = 0.7 +DATATYPES = ["x", "y", "error", "corr_x", "corr_y", "reproj_err", "inlier", "sigma0"] +PROPERTIES = ["x", "y", "pattern_type", "sensor_name", "error_threshold"] +COLUMNS = ["time_utc", "sensor_name", "x", "y", "error_value", "error_threshold", "relative_x", "relative_y", "corr_x", + "corr_y", "reproj_err", "inlier", "sigma0", "pattern_type"] + QUALITY +NUMERIC = ["x", "y", "error_value", "error_threshold", "relative_x", "relative_y", "corr_x", "corr_y", "reproj_err", + "inlier", "sigma0"] + QUALITY +# bandes d'inlier de shift_sensor_1min -> code ; les deux derniers NOMS sont faux (-1 rejeté, -2 interpolé), les codes +# sont justes ; ordre du meilleur au pire +INLIER_BANDS = {"inlier_in_fit": 1.0, "inlier_out_fit": 0.0, "inlier_no_redundancy": -1.0, "inlier_rejected": -2.0} + + +def raison(e): + """L'erreur d'origine (celle de la base) : pandas et SQLAlchemy l'enveloppent, la requête SQL d'abord.""" + while e.__cause__ is not None: + e = e.__cause__ + return f"{type(e).__name__}: {(str(e).splitlines() or [''])[0][:300]}" + + +def lire(conn, sql, **params): + return pd.read_sql(text(sql), conn, params=params) + + +def acquisition_unit(conn, system_id): + """Même choix que Device.get_acquisition_unit (app/base/models.py:268) : l'unique unité, sinon MER* / ME2S*.""" + units = conn.execute(text("SELECT id, product_number FROM acquisition_unit WHERE system_id = :s"), + {"s": system_id}).all() + pick = units if len(units) == 1 else [u for u in units if u.product_number.startswith(("MER", "ME2S"))] + return pick[0].id if pick else None + + +def plages_suivi(dossier, fin, demain): + """Sans --du : (début, fin, remplacer) à pomper, d'après les jours de déplacements déjà pompés. Les jours manquants + entre le premier et le dernier (plages pompées à part, jour en échec) sont comblés sans toucher aux autres ; le + dernier jour est repompé (pompé en cours de journée, il était incomplet) jusqu'à maintenant ; une station sans + déplacements pompés reçoit les 30 derniers jours.""" + jours = {datetime.strptime(p.stem.rsplit("_", 1)[1], "%Y%m%d").date() + for p in (dossier / "displacement").glob(f"{dossier.name}_advanced_*.csv")} + if not jours: + return [(demain - timedelta(days=JOURS_NOUVELLE + 1), fin, True)] + # un jour de métriques en échec n'a aucun fichier (une requête pour toutes) : c'est aussi un trou ; une station + # sans aucune métrique n'en a jamais, ses jours n'en sont pas + metriques = {datetime.strptime(p.name.split(" to ")[0][-16:-6], "%Y_%m_%d").date() + for p in (dossier / "metrics").glob(f"{dossier.name}_*_00_00 to *.csv")} + premier, dernier = min(jours), max(jours) + trous = [premier + timedelta(days=k) for k in range((dernier - premier).days) + if premier + timedelta(days=k) not in jours or (metriques and premier + timedelta(days=k) not in metriques)] + return ([(trous[0], dernier, False)] if trous else []) + [(dernier, fin, True)] + + +def pomper_metriques(conn, system_id, station, debut, fin, out, remplacer): + """Comme le téléchargement de la page System (Dashboard/System.py, get_metrics(..., bucketing="1 hour")) : par + heure, moyenne * transform_factor + transform_offset, ou la liste des valeurs d'une métrique texte ; les séries à + labels d'une même métrique confondues ; une ligne vide pour une heure sans mesure. get_metrics compte en heures + avant maintenant : sa requête est refaite ici sur un jour fixe, une requête par jour pour toutes les métriques.""" + noms = sorted(conn.execute(text("SELECT DISTINCT dt.name FROM datatype dt JOIN metric_series se " + "ON se.datatype_id = dt.id WHERE se.system_id = :s"), {"s": system_id}).scalars()) + conn.rollback() + for k in range((fin - debut).days): + a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) + paths = {n: out / station / "metrics" + / f"{station}_{n.replace(os.sep, '-')}_{a:%Y_%m_%d}_00_00 to {a:%Y_%m_%d}_23_00.csv" for n in noms} + if not remplacer and all(p.exists() for p in paths.values()): + continue + t0 = time.time() + try: + # date_trunc('hour') : même découpage que time_bucket('1 hour') + df = lire(conn, """ + SELECT date_trunc('hour', ms.time_utc) AS heure, dt.name AS nom, + avg(ms.value_num) * any_value(dt.transform_factor) + any_value(dt.transform_offset) AS num, + jsonb_agg(ms.value_text) FILTER (WHERE ms.value_text IS NOT NULL) AS txt + FROM metric_sample ms + JOIN metric_series se ON ms.series_id = se.id + JOIN datatype dt ON se.datatype_id = dt.id + WHERE se.system_id = :s AND ms.time_utc >= :a AND ms.time_utc < :b + GROUP BY 1, dt.name""", s=system_id, a=a, b=a + timedelta(days=1)) + except Exception as e: # ponytail : comme les déplacements, un jour en échec est sauté, relancer le reprend + print(f"{station} {a:%Y-%m-%d} métriques : échec ({raison(e)}), à relancer") + continue + finally: + conn.rollback() + df["heure"] = pd.to_datetime(df["heure"], utc=True) + heures = pd.to_datetime(pd.date_range(a, periods=24, freq="h"), utc=True) # même fuseau que df, pour reindex + # jour en cours : les heures terminées seulement, sinon les heures à venir seraient lues comme un trou + heures = heures[heures + pd.Timedelta(hours=1) <= pd.Timestamp.now(tz=UTC)] + for n, path in paths.items(): + d = df[df["nom"] == n].set_index("heure") + col = d["num"] if d["num"].notna().any() else d["txt"] # métrique texte : la liste de l'heure + path.parent.mkdir(parents=True, exist_ok=True) + # CSV de la page System : ',time_utc,metric', l'index en première colonne ; un jour vide est écrit aussi + pd.DataFrame({"time_utc": heures, "metric": col.reindex(heures).to_numpy()}).to_csv(path) + print(f"{station} {a:%Y-%m-%d} métriques : {len(noms)} fichiers, {df['nom'].nunique()} avec mesure, " + f"{time.time() - t0:.0f} s") + + +# --- l'export « advanced » : build_advanced_frame (app/datapoints.py) --- + +def datapoints_bruts(conn, unit, a, b): + """AcquisitionUnit.get_datapoints : les datapoints de l'unité, un type par colonne, les propriétés des capteurs + à côté (prop_x / prop_y : la position de référence, homonyme d'un type).""" + types = ",\n".join(f"max(d.value) FILTER (WHERE dt.name = '{t}') AS {t}" for t in DATATYPES) + noms = {p: f"prop_{p}" if p in DATATYPES else p for p in PROPERTIES} + props = ",\n".join(f"any_value(p_{p}.value) AS {noms[p]}" for p in PROPERTIES) + joints = "\n".join(f"LEFT JOIN (SELECT p.sensor_id, p.value FROM property p JOIN datatype pdt " + f"ON p.datatype_id = pdt.id WHERE pdt.name = '{p}') p_{p} ON d.sensor_id = p_{p}.sensor_id" + for p in PROPERTIES) + return lire(conn, f""" + SELECT d.time_utc, d.sensor_id, any_value(d.measurement_id) AS measurement_id, + {types}, + {props} + FROM datapoint d + JOIN sensor s ON d.sensor_id = s.id + JOIN datatype dt ON d.datatype_id = dt.id + {joints} + WHERE s.acquisition_unit_id = :au AND d.time_utc >= :a AND d.time_utc <= :b + GROUP BY d.time_utc, d.sensor_id + ORDER BY d.sensor_id, d.time_utc""", au=unit, a=a, b=b) + + +def preparer_bruts(shifts): + """prepare_datapoints_frame : sigma0 (lignes de la caméra, sans sensor_name) recopié sur chaque capteur à son + instant ; relative = x - prop_x ; error -> error_value ; le schéma complet.""" + if shifts.empty: + return pd.DataFrame(columns=COLUMNS) + sig = shifts.loc[shifts["sigma0"].notna(), ["time_utc", "sigma0"]] + sigma0 = sig.groupby("time_utc")["sigma0"].median() if not sig.empty else None + shifts = shifts.dropna(subset=["sensor_name"]).reset_index(drop=True) + shifts["sigma0"] = shifts["time_utc"].map(sigma0) if sigma0 is not None else pd.NA + shifts["relative_x"] = shifts["x"] - pd.to_numeric(shifts["prop_x"], errors="coerce") + shifts["relative_y"] = shifts["y"] - pd.to_numeric(shifts["prop_y"], errors="coerce") + shifts = shifts.drop(columns=["prop_x", "prop_y"]).rename(columns={"error": "error_value"}) + shifts["time_utc"] = pd.to_datetime(shifts["time_utc"]) + shifts["sensor_name"] = shifts["sensor_name"].astype(str) + for c in NUMERIC: + if c in shifts: + shifts[c] = pd.to_numeric(shifts[c], errors="coerce") + return shifts.reindex(columns=COLUMNS) + + +def etats_agreges(conn, unit, a, b): + """fetch_aggregate_datapoints_frame : les médianes par minute des tables d'états (shift_sensor_1min, + shift_common_1min), seule source des appareils « burst », au schéma de l'export (prepare_aggregate_datapoints_frame). + Dans les états, x_pct porte le x CORRIGÉ et rx_pct le x brut.""" + thr = "COALESCE((th.value #>> '{}')::double precision, CAST(:thr AS double precision))" + sensor = lire(conn, f""" + SELECT ss.time_utc, COALESCE(sn.value #>> '{{}}', s.name) AS name, + approx_percentile(0.5, ss.x_pct) AS corr_x, approx_percentile(0.5, ss.y_pct) AS corr_y, + approx_percentile(0.5, ss.rx_pct) AS x, approx_percentile(0.5, ss.ry_pct) AS y, + approx_percentile(0.5, ss.error_pct) AS error, {thr} AS error_threshold, + approx_percentile(0.5, ss.reproj_err_pct) AS reproj_err, + {", ".join(f"ss.{n}" for n in INLIER_BANDS)}, + {", ".join(f"approx_percentile(0.5, ss.{m}_pct) AS {m}" for m in QUALITY)} + FROM shift_sensor_1min ss + JOIN sensor s ON s.id = ss.sensor_id + LEFT JOIN (SELECT p.sensor_id, any_value(p.value) AS value FROM property p JOIN datatype dt + ON dt.id = p.datatype_id WHERE dt.name = 'sensor_name' GROUP BY p.sensor_id) sn + ON sn.sensor_id = ss.sensor_id + LEFT JOIN (SELECT p.sensor_id, any_value(p.value) AS value FROM property p JOIN datatype dt + ON dt.id = p.datatype_id WHERE dt.name = 'error_threshold' GROUP BY p.sensor_id) th + ON th.sensor_id = ss.sensor_id + WHERE s.acquisition_unit_id = :au AND ss.time_utc >= :a AND ss.time_utc <= :b + ORDER BY ss.time_utc""", au=unit, a=a, b=b, thr=DEFAULT_ERROR_THRESHOLD) + if sensor.empty: + return pd.DataFrame(columns=COLUMNS) + common = lire(conn, """ + SELECT sc.time_utc, approx_percentile(0.5, sc.sigma0_pct) AS sigma0 FROM shift_common_1min sc + WHERE sc.acquisition_unit_id = :au AND sc.time_utc >= :a AND sc.time_utc <= :b""", au=unit, a=a, b=b) + out = pd.DataFrame({"time_utc": pd.to_datetime(sensor["time_utc"]), "sensor_name": sensor["name"].astype(str)}) + for col, src in [("error_value", "error"), ("error_threshold", "error_threshold"), ("corr_x", "corr_x"), + ("corr_y", "corr_y"), ("relative_x", "corr_x"), ("relative_y", "corr_y"), ("x", "x"), ("y", "y"), + ("reproj_err", "reproj_err")] + [(m, m) for m in QUALITY]: + out[col] = pd.to_numeric(sensor[src], errors="coerce") + # inlier_code_from_bands : la bande majoritaire, l'égalité à la pire ; toutes à 0 -> NaN (pas de redondance) + counts = sensor[list(INLIER_BANDS)].apply(pd.to_numeric, errors="coerce").fillna(0) + code = counts[list(INLIER_BANDS)[::-1]].idxmax(axis=1).map(INLIER_BANDS) + out["inlier"] = code.where(counts.sum(axis=1) > 0).to_numpy() + out["pattern_type"] = None + sig = common.loc[common["sigma0"].notna()] + out["sigma0"] = (out["time_utc"].map(sig.assign(time_utc=pd.to_datetime(sig["time_utc"])) + .groupby("time_utc")["sigma0"].median()) if not sig.empty else float("nan")) + return out.reindex(columns=COLUMNS) + + +def fusionner(raw, agg): + """merge_raw_and_aggregate_frames : le brut gagne ; un état n'est gardé que là où son capteur n'a pas de ligne + brute dans la même minute.""" + if agg.empty: + return raw + if raw.empty: + return agg + + def utc(t): + t = pd.to_datetime(t) + return t.dt.tz_localize("UTC") if t.dt.tz is None else t.dt.tz_convert("UTC") + + cles = pd.MultiIndex.from_arrays([raw["sensor_name"], utc(raw["time_utc"]).dt.floor("1min")]) + agg = agg.loc[~pd.MultiIndex.from_arrays([agg["sensor_name"], utc(agg["time_utc"]).dt.floor("1min")]).isin(cles)] + if agg.empty: + return raw + agg = agg.copy() + tz = pd.to_datetime(raw["time_utc"]).dt.tz + t = utc(agg["time_utc"]) + agg["time_utc"] = t.dt.tz_convert(tz) if tz is not None else t.dt.tz_localize(None) + return (pd.concat([raw, agg], ignore_index=True).sort_values(["sensor_name", "time_utc"], kind="stable") + .reset_index(drop=True).reindex(columns=COLUMNS)) + + +def advanced(conn, unit, a, b): + return fusionner(preparer_bruts(datapoints_bruts(conn, unit, a, b)), etats_agreges(conn, unit, a, b)) + + +def camera(conn, unit, a, b): + """Pan, tilt, scale, rotation et sigma0 de la caméra, en médiane et bornes (median_ / min_ / max_) par minute, donc + une ligne par mesure de la caméra (toutes les 15 min à NORDEND, min = max) : ce que trace le visualiseur + (fetch_cam_movements_frame), sans son except, qui rendrait vide un jour en échec au lieu de le laisser à relancer.""" + sigs = ", ".join(f"approx_percentile(0.5, sc.{s}_pct) AS median_{s}, min_val(sc.{s}_pct) AS min_{s}, " + f"max_val(sc.{s}_pct) AS max_{s}" for s in CAM_SIGNALS) + return lire(conn, f"""SELECT sc.time_utc, {sigs} FROM shift_common_1min sc + WHERE sc.acquisition_unit_id = :au AND sc.time_utc >= :a AND sc.time_utc <= :b + ORDER BY sc.time_utc""", au=unit, a=a, b=b) + + +JOURS = (("displacement", "advanced", advanced), ("camera", "camera", camera)) # dossier, fichier, lecture + + +def pomper_deplacements(conn, unit, station, debut, fin, out, remplacer): + """Déplacements et mouvements de la caméra : un fichier et une requête par jour, bornée, sous le délai (--delai).""" + for k in range((fin - debut).days): + a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) + for dossier, nom, lecture in JOURS: + path = out / station / dossier / f"{station}_{nom}_{a:%Y%m%d}.csv" + if path.exists() and not remplacer: + continue + t0 = time.time() + try: + df = lecture(conn, unit, a, a + timedelta(days=1) - timedelta(microseconds=1)) + except Exception as e: # ponytail : un jour en échec est sauté, relancer le reprend ; pas de nouvel essai + print(f"{station} {a:%Y-%m-%d} {nom} : échec ({raison(e)}), à relancer") + continue + finally: + conn.rollback() # ferme la transaction de lecture + if "sensor_name" in df: + df = df.drop_duplicates(["sensor_name", "time_utc"]) + path.parent.mkdir(parents=True, exist_ok=True) + df.to_csv(path, index=False) # un jour vide est écrit aussi : la relance ne le redemande pas + print(f"{station} {a:%Y-%m-%d} {nom}: {len(df)} lignes, {time.time() - t0:.0f} s -> {path.name}") + + +def pomper_images(conn, s3, unit, station, debut, fin, dossier, every, out): + mt = conn.execute(text("SELECT id, extension FROM measurement_type WHERE name = :n"), {"n": TYPES[dossier]}).first() + if mt is None: + print(f"{station} : type {TYPES[dossier]} inconnu") + return + client, bucket_s3 = s3 + for k in range((fin - debut).days): + a = datetime.combine(debut + timedelta(days=k), datetime.min.time(), UTC) + mesures = conn.execute(text( + "SELECT id, time_utc, measurement_uuid FROM measurement WHERE acquisition_unit_id = :au " + "AND measurement_type_id = :mt AND time_utc >= :a AND time_utc < :b ORDER BY time_utc"), + {"au": unit, "mt": mt.id, "a": a, "b": a + timedelta(days=1)}).all() + conn.rollback() + seen, n, octets, sans_uuid, absentes = set(), 0, 0, 0, 0 + for m in mesures: + # measurement_uuid vide : l'image n'est jamais arrivée sur S3 (envoi en plusieurs parties inachevé) ; + # écartée, la tranche prend l'image suivante s'il y en a une + if m.measurement_uuid is None: + sans_uuid += 1 + continue + t = m.time_utc.astimezone(UTC) + bucket = (t.hour * 60 + t.minute) // every if every else m.id # une image par tranche de `every` min + path = out / station / dossier / f"{t:%Y%m%dT%H%M}Z_{m.id}.{mt.extension}" + if bucket in seen: + continue + seen.add(bucket) # même déjà là : sinon la relance prendrait l'image suivante de la tranche + if path.exists(): + continue + try: + data = client.get_object(Bucket=bucket_s3, Key=m.measurement_uuid)["Body"].read() + except Exception: # comme get_measurement_payload : S3 qui ne répond pas, l'image est comptée absente + data = None + if data: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(data) + n, octets = n + 1, octets + len(data) + else: + absentes += 1 + # le détail dit pourquoi un jour rend 0 : rien en base, jamais arrivées sur S3, ou S3 qui ne les rend pas + print(f"{station} {a:%Y-%m-%d} {dossier}: {n} nouvelles images, {octets / 1e6:.0f} Mo " + f"({len(mesures)} en base, {sans_uuid} jamais arrivées sur S3, {absentes} non rendues par S3)") + time.sleep(0.5) + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument("stations", nargs="*", help="numéro de série du système, comme dans l'URL de la page System ; " + "aucun : ceux de stations.txt") + p.add_argument("--du", help="premier jour UTC, AAAA-MM-JJ ; sans : le dernier jour pompé de chaque station, " + "repompé, ou les 30 derniers jours") + p.add_argument("--au", help="dernier jour UTC exclu, AAAA-MM-JJ ; sans : jusqu'à maintenant") + p.add_argument("--images", action="store_true", help="aussi les images OPTICAL_SHIFT-IRON") + p.add_argument("--diff", action="store_true", help="aussi les images OPTICAL_SHIFT-DIFF") + p.add_argument("--every", type=int, default=60, help="une image par tranche de N minutes, 0 = toutes (défaut 60)") + p.add_argument("--delai", type=int, default=60, help="délai maximal d'une requête, en s (défaut 60 : base partagée " + "avec la production) ; plus long seulement pour un jour en échec par délai dépassé") + p.add_argument("--out", type=Path, default=Path(__file__).resolve().parent.parent / "data") + a = p.parse_args() + demain = datetime.now(UTC).date() + timedelta(days=1) + du = datetime.strptime(a.du, "%Y-%m-%d").date() if a.du else None + fin = min(datetime.strptime(a.au, "%Y-%m-%d").date(), demain) if a.au else demain # pas de jour à venir + stations = a.stations or STATIONS.read_text().split() + + missing = [n for n in DB_NAMES if not os.environ.get(n)] + if missing: + sys.exit(f"Variables absentes (noms seulement) : {', '.join(missing)}") + url = URL.create("postgresql+psycopg2", username=os.environ["AIMSIGHT_DATABASE_USER"], + password=os.environ["AIMSIGHT_DATABASE_PSWD"], host=os.environ["AIMSIGHT_DATABASE_TURL"], + port=int(os.environ.get("AIMSIGHT_DATABASE_PORT", "5432")), + database=os.environ["AIMSIGHT_DATABASE_NAME"]) + engine = create_engine(url, connect_args={ + "options": f"-c timezone=utc -c default_transaction_read_only=on -c statement_timeout={a.delai}s"}) + s3 = None + if a.images or a.diff: + import boto3 # comme S3client de l'appli (Garage) + s3 = (boto3.client("s3", endpoint_url=os.environ.get("AIMSIGHT_S3_URL", "http://s3:3900"), + aws_access_key_id=os.environ.get("AIMSIGHT_S3_ACCESS_KEY", ""), + aws_secret_access_key=os.environ.get("AIMSIGHT_S3_SECRET_KEY", ""), + region_name="garage", use_ssl=False), + os.environ.get("AIMSIGHT_S3_BUCKET", "measurements-assets")) + try: + with engine.connect() as conn: + for station in stations: + system_id = conn.execute(text("SELECT id FROM system WHERE serial_number = :s"), {"s": station}).scalar() + if system_id is None: + print(f"{station} : système inconnu") + continue + plages = [(du, fin, False)] if du else plages_suivi(a.out / station, fin, demain) + unit = acquisition_unit(conn, system_id) + conn.rollback() + for debut, fin_plage, remplacer in plages: + print(f"{station} : du {debut} au {fin_plage - timedelta(days=1)} inclus" + + ("" if remplacer else ", jours manquants seulement")) + pomper_metriques(conn, system_id, station, debut, fin_plage, a.out, remplacer) + if unit is None: + print(f"{station} : pas d'unité d'acquisition reconnue, ni déplacements, ni caméra, ni images") + continue + pomper_deplacements(conn, unit, station, debut, fin_plage, a.out, remplacer) + for flag, dossier in ((a.images, "images"), (a.diff, "images_diff")): + if flag: + pomper_images(conn, s3, unit, station, debut, fin_plage, dossier, a.every, a.out) + finally: + engine.dispose() + + +if __name__ == "__main__": + main() diff --git a/extraction/pomper.sh b/extraction/pomper.sh new file mode 100755 index 0000000..ffeb15f --- /dev/null +++ b/extraction/pomper.sh @@ -0,0 +1,25 @@ +#!/usr/bin/env bash +# Pompage sous WSL. Lit les identifiants dans le .env à la racine du dépôt (jamais versionné), +# 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" diff --git a/extraction/stations.txt b/extraction/stations.txt new file mode 100644 index 0000000..f4d2353 --- /dev/null +++ b/extraction/stations.txt @@ -0,0 +1,13 @@ +BREITHORN +CLARIDEN +FLORIDA +JUNGFRAU +LENZSPITZE +MICHIGAN +NADELHORN +NEBRASKA +NIEDERHORN +NORDEND +WILDSTRUBEL +SUSTENHORN +SNCF01 \ No newline at end of file diff --git a/labeling/familles.md b/labeling/familles.md index 2bb70ca..7192f41 100644 --- a/labeling/familles.md +++ b/labeling/familles.md @@ -1,6 +1,6 @@ # Les familles des étiquettes -Une étiquette, une anomalie, une famille (D-109 à D-111, D-119). Une anomalie, c'est ce qui apparaît sur `corr_x` et `corr_y` : les courbes bougent (un pic, un saut, une dérive, du bruit) ou manquent (un trou). La famille dit la **cause** de ce qui se voit sur les courbes corrigées, ou de ce qui y manque, et ce qu'il faut en conclure pour le client. Sa clé, son nom même, va dans le champ `categorie` de l'étiquette ; l'outil d'étiquetage la propose dans son menu Category. Chaque famille a son détecteur, dans `detectors/` (D-119) : la catégorie d'un événement du journal est sa famille. +Une étiquette, une anomalie, une famille (D-109 à D-111, D-119). Une anomalie, c'est ce qui apparaît sur `corr_x` et `corr_y` : les courbes bougent (un pic, un saut, une dérive, du bruit) ou manquent (un trou). La famille dit la **cause** de ce qui se voit sur les courbes corrigées, ou de ce qui y manque, et ce qu'il faut en conclure pour le client. Sa clé, son nom même, va dans le champ `categorie` de l'étiquette ; l'outil d'étiquetage la propose dans son menu Category. Chaque famille a son détecteur, dans `detectors/scripts/` (D-119) : la catégorie d'un événement des détecteurs est sa famille. | Clé | Détecteur | Ce qui arrive | Pour le client | Phénomènes de la carte des étiquettes | |---|---|---|---|---|