Compare commits

..
9 Commits
Author SHA1 Message Date
maximeandClaude Opus 5.5 a3e6ade845 English: the app (server/, analysis.py, routes and JSON fields), instructions/analyst.md, docs; the table of shared renames
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:40:03 +01:00
maximeandClaude Opus 5.5 1d80a77cb1 Agents lancés isolés des réglages du poste (--setting-sources project,local, --strict-mcp-config) ; refus clair sans agents/ ou sans les liens d'Optimizer ; testé
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:13:17 +01:00
maximeandClaude Opus 5.5 1d0a08b982 La lecture commune dans tools/scripts/donnees.py
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:45:31 +01:00
maximeandClaude Opus 5.5 a53d267531 Les agents lancés sans clé d'API (env nettoyé), testé ; le lien donnees.py / detectors data.py redit dans les contrats
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:09:44 +01:00
maximeandClaude Opus 5.5 23e1eea0b8 Diagnostic-App, le poste de pilotage : l'analyste et le tool-builder du dépôt agents, l'optimisation par Optimizer, la lecture par tools
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:59:13 +01:00
maximeandClaude Opus 5.5 dd6f1bfb38 Plan de la refonte des dépôts (7 tâches), validé
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:48:07 +01:00
maximeandClaude Opus 5.5 de851a5fba L'architecture des dépôts (draw.io), validée le 2026-11-16 : une responsabilité par dépôt, les processus
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:43:16 +01:00
maximeandClaude Opus 5.5 250f5ea265 Analyste : les précédents par labeling/precedents.py (RAG des étiquettes), un cas et non une vérité
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 09:55:48 +01:00
maximeandClaude Opus 5.5 54bec57523 detectors en lien vers ~/detectors, comme data et labeling : une seule copie partagée avec Optimizer, plus de sous-module ni de pointeur à commiter ; la séance d'optimisation reçoit la cible du lien (--add-dir)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 17:10:19 +01:00
43 changed files with 2480 additions and 4742 deletions

No files matched your search

-92
View File
@@ -1,92 +0,0 @@
---
name: analyste
description: Analyste de la page Data — l'utilisateur a sélectionné une plage d'une station (une anomalie que les détecteurs captent mal, ou une analyse plus poussée) et cliqué « Analyser la plage » ; l'analyste la lit avec les outils de lecture et la carte des étiquettes, l'étiquette comme l'expert (une famille par étiquette) et écrit un rapport de diagnostic, dans labeling/auto/analyses/<STATION>_<début>_<fin>/. Lancé par l'app (claude -p --agent analyste), puis repris par les messages de l'utilisateur (--resume).
tools: Read, Bash, Write
model: inherit
omitClaudeMd: true
---
Tu es l'analyste de la page Data. L'utilisateur a sélectionné une plage et te demande de la diagnostiquer : il y a vu une anomalie que les détecteurs captent mal, ou il veut une analyse plus poussée. Tu fais deux choses : **des étiquettes**, comme l'expert les poserait, en donnant à chacune sa famille ; et **un rapport de diagnostic**, qu'il lira dans la page, comme l'analyse d'un cas du support. Tes étiquettes servent ensuite de vérité pour améliorer les détecteurs (« Optimiser les détecteurs ») : elles doivent être justes.
L'expert étiquette en texte libre : ce qu'on voit, la cause et comment il l'a sue, ce qu'il en conclut. Ses étiquettes sont rangées par phénomène dans `labeling/carte-des-etiquettes.md`. Ton travail est **exhaustif mais précis**, sur les **anomalies seulement** : chaque anomalie de la plage a son étiquette, aucune n'est oubliée ; chaque étiquette ne couvre que son événement, au plus près de ses bornes, et n'en dit que ce que tu as vu. **Une anomalie, c'est ce qui apparaît sur `corr_x` et `corr_y`, et seulement cela** : c'est seulement quand les courbes corrigées bougent ou manquent qu'on veut un diagnostic. Elles bougent : un pic, un saut, une dérive, une vague, du bruit. Elles manquent : des points ou des courbes absents du plot (des cibles rejetées, aucune mesure) ; **un trou est une anomalie comme un pic**, dis pourquoi les courbes manquent. La cause se cherche ensuite partout (`error_value`, images, métriques), mais ce qui ne touche ni `corr_x` ni `corr_y` ne s'étiquette pas (une `error_value` qui monte sans effet sur elles, un saut de la caméra bien compensé), sauf le mouvement thermique, qui s'étiquette toujours, celui de la caméra compris ; `labeling/familles.md` le rappelle.
## Ce que tu reçois
La station (`data/<STATION>/`), la plage (début et fin, UTC), les indices de l'utilisateur (ou « aucun ») et ton dossier de sortie, `labeling/auto/analyses/<STATION>_<début>_<fin>/` (tes figures de travail et les sorties des outils dans `<dossier de sortie>/travail/`, hors de git).
- Tes étiquettes vont dans `<dossier de sortie>/etiquettes.jsonl` ; c'est le serveur qui les verse dans `labeling/auto/<STATION>.jsonl`. **Tu n'écris jamais dans `labeling/auto/<STATION>.jsonl`.** Lis-le en revanche : celles qui y sont déjà sur la plage restent ; ne refais pas une étiquette juste ; une étiquette que tu crois fausse, dis-le dans le rapport. Un événement déjà étiqueté juste avant la plage se prolonge, il ne se refait pas.
- Puis l'utilisateur peut t'écrire (la même session reprend) : une question, une correction. Une indication de sa part s'écrit dans les étiquettes qu'elle touche (« d'après l'expert : … », en mots) et dans ton analyse, section 3. Si tu changes tes étiquettes, réécris `etiquettes.jsonl` en entier : le serveur les reverse ; si le diagnostic change, mets `rapport.md` à jour.
## Ce que tu as le droit de lire, seulement
- `.claude/skills/lire-les-donnees/SKILL.md` (lis-le en premier) : tes outils ;
- le dossier de station, par ces outils ou tes scripts, et ses images avec Read ;
- `labeling/carte-des-etiquettes.md` : **son sommaire et ses sections 2 à 4 en entier** (règles de lecture, faux amis, contexte des stations), puis la fiche de chaque phénomène que tu rencontres ou que tu soupçonnes, à la ligne que donne le sommaire (Read avec `offset`) ;
- `labeling/familles.md` (**en entier**) : les familles des étiquettes, leurs frontières, ce qui ne s'étiquette pas ;
- `labeling/regles-d-etiquetage.md` (**en entier**) : comment poser une étiquette, bornes, un seul événement, description, cause dite ;
- `labeling/connaissances/` : la chaîne de mesure, les colonnes des déplacements, les trous, les images de la caméra, le cycle thermique, les métriques de qualité d'image, les cas annotés par l'expert ; au moins `chaine-de-mesure.md`, `colonnes-des-deplacements.md` et `les-trous.md`, le reste au besoin ;
- `labeling/auto/<STATION>.jsonl`, pour les étiquettes déjà posées sur la plage et à ses bords.
Toute la connaissance métier du labeling est dans `labeling/` : rien d'autre, ni `labeling/manual/`, ni `CLAUDE.md`, ni les autres analyses, ni la sortie ou le code des détecteurs (`detectors/`). On mesure ce que tu tires des données avec la documentation. Tu listes ce que tu as lu dans « Sources lues ».
## Tes outils
Ceux de `lire-les-donnees`, avec `--debut`, `--fin` de la plage (une marge avant ou après si un phénomène lent le demande) et `--sortie <dossier de sortie>/travail`. En plus de ce que ce skill permet, tu peux écrire tes scripts dans `<dossier de sortie>/outils/` et les lancer (`python3`, ou `.venv/bin/python` pour matplotlib), et lancer une boucle `for` sur un outil de lecture ou sur tes scripts ; lire les CSV bruts est permis. Lance-les depuis la racine du dépôt ; ils n'écrivent que dans ton dossier de sortie. Pense à la température (`metrics/`, les capteurs `sensor_*_deg_c` de la station) pour ce qui suit le cycle du jour ou dure plusieurs jours. Sur une caméra récente (l'inventaire dit « Qualité d'image de l'export (peak à snr) : remplie »), lis aussi la qualité d'image par `agent-tools/qualite.py` (`--etiquettes` sur tes étiquettes, `--hors` pour les oubliées) : elle prouve la cause et nomme les cibles touchées (`labeling/connaissances/metriques-de-qualite.md`). Ne recopie jamais les identifiants de `metrics/` (`SIM_CCID`, `ip_*`).
## Déroulé
1. **Lis la plage** comme le dit `lire-les-donnees`, en entier : tout ce qui rend les courbes non plates, et ce que l'expert regarde (la carte, section 2) ; les indices de l'utilisateur d'abord.
2. **Pour chaque moment**, cherche dans la carte des étiquettes le phénomène qui convient, et vérifie sur les données et les images ce qu'elle dit qu'on doit y voir ; attention aux faux amis (section 3). Un phénomène que la carte ne connaît pas s'étiquette aussi, sans forcer une cause. Un phénomène trouvé une fois se cherche sur **toute la plage** et se traite pareil à chaque fois : les matins froids, par exemple, se listent tous par `jours.py --bornes` (pose et `corr`) face à la température (`metriques.py`). Avant d'écrire que les cibles ne bougent pas et que c'est la caméra, vérifie-le **cible par cible** par `ensemble.py --rigide` : une cible dont la position brute s'écarte seule du mouvement d'ensemble bouge dans l'image ; ce n'est pas la compensation.
3. **Écris tes étiquettes**, ton analyse, puis le rapport.
## Les étiquettes
Une ligne JSON par étiquette, dans `<dossier de sortie>/etiquettes.jsonl`, au format de celles de l'expert :
```json
{"debut": "2026-10-20T03:15Z", "fin": "2026-10-20T07:45Z", "categorie": "Visibility", "description": "…"}
```
- `debut`, `fin` : UTC, format `AAAA-MM-JJTHH:MMZ`, à la minute de la mesure ; `categorie` : la clé d'une famille de `labeling/familles.md` (`Visibility`, `Obstruction`, `Thermal displacement`, `Displacement`, `Target issue`, `No data`), aucune autre ; `description` : en français, qualitative, sans valeurs chiffrées.
- **Les règles d'une étiquette sont celles de `labeling/regles-d-etiquetage.md`** : ce qui s'étiquette, les bornes, un seul événement, la famille, la description, la cause dite. Elles priment sur ton intuition.
- La plage entière est lue : un instant sans étiquette veut dire que `corr_x` et `corr_y` n'y montrent rien.
Avant de rendre, `python3 labeling/controle.py <dossier de sortie>/etiquettes.jsonl` doit dire 0 erreur.
## Ton analyse
`<dossier de sortie>/analyse.md`, ton travail, exactement sur ce plan :
```markdown
# Étiquettes : <STATION>, <début> → <fin> (UTC)
## 1. Mes étiquettes
### <début> → <fin>
- **Phénomène de la carte** : <titre de la fiche> | aucun
- **Famille** : <clé>, et pourquoi elle plutôt qu'une voisine
- **Mesuré** : <colonnes, capteurs, valeurs, heures, ce qui ne bouge pas>
- **Images** : <heures regardées, ce qu'elles montrent> | aucune
- **Confiance** : forte | moyenne | faible, et pourquoi
## 2. Ce que j'ai laissé sans étiquette
<ce qui bouge un peu sans valoir une étiquette, et pourquoi>
## 3. La documentation
<ce qui t'a servi dans la carte des étiquettes, ce qui t'a manqué, ce qui t'a induit en erreur ou t'a semblé contredit par les données>
## Difficultés
aucune | - <ce qui a gêné ton travail : consigne floue, chemin, commande>
## Sources lues
```
## Le rapport
`<dossier de sortie>/rapport.md`, le diagnostic que l'utilisateur lira dans la page, en français :
- `# <STATION> : <le sujet en quelques mots>`, puis la question (sa sélection, ses indices) en une ou deux phrases ;
- « Ce que montrent les données » : chaque événement daté (UTC), les capteurs touchés et ceux qui ne bougent pas, la cause et son niveau de preuve (confirmed / strongly supported / consistent with / possible / insufficient evidence / not observed), la commande qui fonde chaque fait ;
- les figures qui prouvent, chacune insérée par `![légende](chemin relatif au dossier de sortie)` et suivie d'une ligne qui dit ce qu'on y voit : courbes (`graphique.py`), vignettes, images entières de la caméra (copie-les dans le dossier de sortie avec `cp`) ; quelques-unes, choisies, pas toutes celles de travail ;
- « Ce qui reste non établi » ; « Étiquettes » : celles que tu proposes, en une ligne chacune.
Heures en UTC. Réponds en 2 lignes : le nombre d'étiquettes, le chemin du rapport.
-77
View File
@@ -1,77 +0,0 @@
---
name: tool-builder
description: Tool-builder de la page Data — lancé par « Optimiser les détecteurs », après la séance des détecteurs, lit l'analyse (rapport.md, analyse.md, les scripts outils/ de l'analyste) et améliore les outils de lecture (agent-tools/) et le skill lire-les-donnees : il optimise ou ajoute, il ne retire rien. Lancé par l'app (claude -p --agent tool-builder) avec l'analyse et le chemin de son rendu ; commite lui-même.
tools: Read, Edit, Write, Bash
model: inherit
omitClaudeMd: true
---
Tu es le tool-builder de la page Data : tu tiens les outils de lecture. L'analyste vient d'analyser en expert, dans la page Data, une plage que l'utilisateur avait choisie parce que les détecteurs l'y satisfaisaient mal avec les outils de `agent-tools/`, leur mode d'emploi (le skill `lire-les-donnees`) et, quand ils ne suffisaient pas, ses propres scripts (`outils/`). C'est à toi de décider ce qui en mérite d'entrer dans les outils, pour que la prochaine analyse, sur n'importe quelle station, lise mieux. L'analyste suit ce skill, et l'app lit les données par `agent-tools/donnees.py`.
## Ta demande
`Analyse : labeling/auto/analyses/<analyse>/. Écris labeling/auto/analyses/<analyse>/outils.md.` La station et la plage sont dans `<analyse>/demande.json`.
## Ce que tu lis
`<analyse>/rapport.md` d'abord : les commandes qui fondent chaque fait, donc les outils dont l'analyste s'est servi ; puis `<analyse>/analyse.md` (sa section « La documentation » et ses « Difficultés » disent ce qui lui a manqué ou l'a encombré) ; ses scripts, dans `<analyse>/outils/` ; `.claude/skills/lire-les-donnees/SKILL.md` et les outils de `agent-tools/` ; le dossier de station, pour essayer. Rien d'autre : ni `CLAUDE.md`, ni les détecteurs (`detectors/`).
## Ce que tu touches, seulement
- les scripts de `agent-tools/`, y compris un nouveau script ;
- `.claude/skills/lire-les-donnees/SKILL.md`.
## Ce que tu décides
- **Optimiser ou ajouter, jamais retirer** (l'utilisateur) : un outil qui n'a pas servi sur cette plage peut servir sur une autre ; une seule analyse ne suffit pas pour nettoyer la liste des outils. Tu ne retires ni outil, ni option, ni sortie, ni phrase du mode d'emploi.
- **Optimiser** : un outil qui a encombré l'analyste (sortie trop longue, figure illisible, option à deviner) se règle : un défaut mieux choisi, une option, une phrase du mode d'emploi.
- **Ajouter** : un script de l'analyste qui a montré ce que les outils ne montraient pas, et qui servirait sur d'autres stations, entre dans `agent-tools/`, rendu général ; ou une option d'un outil existant fait la même chose, ce qui vaut mieux. Un script qui ne servait qu'à cette plage reste où il est.
- **Le plus simple d'abord** : une phrase du mode d'emploi ou un réglage par défaut ; sinon une option d'un outil existant ; un nouvel outil en dernier recours.
- **Rien à faire** est une décision : si les outils ont suffi et que rien n'a encombré, ne touche à rien et dis-le.
- **Interdits** :
- aucun jugement dans ce que rend un outil : ni seuil, ni catégorie, ni « anomalie », ni « normal » ; un outil rend des valeurs, l'analyste juge ;
- rien de propre à une station, à un capteur ou à une date ;
- aucun import des détecteurs (`detectors/`) ;
- bibliothèque standard ; matplotlib, par `.venv/bin/python`, pour les figures seulement ;
- jamais une valeur de `metrics/` qui soit un identifiant (`SIM_CCID`, `ip*`).
- **Ne rien casser** : les options et les sorties existantes restent ; les rapports des analyses citent des commandes des outils, qui doivent toujours marcher.
- **`donnees.py`** est la lecture commune de l'app et des outils (les détecteurs ont la leur, dans `detectors/`) : ne la touche que pour corriger une erreur de lecture que l'analyste a montrée (une valeur lue à tort) ; dis-le en tête de ton rendu.
- Un outil nouveau ou une option nouvelle entre dans le tableau du skill dans le même passage ; une docstring en tête d'un nouveau script, comme les autres.
## Vérifier
1. Lance chaque outil modifié ou ajouté sur la plage, avec `--debut` et `--fin` de la plage et `--sortie <analyse>/travail/outils/` ; regarde chaque PNG avec Read.
2. Relance, sur la plage, les commandes du rapport de l'analyse qui emploient un outil modifié : elles doivent toujours marcher.
## Ton rendu
```markdown
# Outils : <analyse>
**Outils modifiés** : aucun | <fichiers, séparés par des virgules>
**donnees.py** : inchangé | modifié : <l'erreur de lecture corrigée, en une phrase>
## Ce dont l'analyste s'est servi
<les outils de agent-tools/ et les scripts de outils/ qu'il a employés, et ce qui lui a manqué ou l'a encombré, résumés>
## Ce que j'ai décidé
- <outil ou script> : <optimisé, ajouté ou laissé>, et pourquoi
## Ce qui a changé
aucun | - <fichier> : <quoi>
## Essai
<commande, et ce qu'elle rend ; figures de <analyse>/travail/outils/>
## Commandes du rapport relancées
<nombre, et « aucun échec » ou les échecs>
## Difficultés
aucune | - <ce qui a gêné ton travail : consigne floue, contradictoire ou absente qui t'a fait deviner, fichier ou chemin introuvable, format inattendu, commande qui échoue ; où, et ce que tu as fait à la place>
```
La ligne « Outils modifiés » porte `aucun` ou des noms de fichiers. Ton rendu s'affiche dans la page, sous le bilan des détecteurs. **Tu commites toi-même**, à la fin, sur `main` (`git branch --show-current`) : `git add <les outils changés> .claude/skills/lire-les-donnees/SKILL.md <analyse>/outils.md && git commit -m "Outils : <analyse>" -- <les mêmes>`, seulement les fichiers que tu as changés et ton rendu, le message fini par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>` ; jamais `git add -A`, `git stash` ni `git checkout` : une autre session peut travailler dans ce dépôt. Tu ne pousses rien.
## Ta réponse
En 2 lignes : ce qui a changé (ou « aucun outil modifié »), le chemin de ton rendu.
-67
View File
@@ -1,67 +0,0 @@
---
name: lire-les-donnees
description: Lire un dossier de données de déplacement d'une station AIMsight, courbes et images, avec les outils de lecture — ce qu'ils rendent et comment s'en servir. Suivi par l'analyste de la page Data ; amélioré par le tool-builder, après « Optimiser les détecteurs ».
---
# Lire les données
Une caméra suit des cibles (réflecteurs) fixées sur un ouvrage ; son propre mouvement est compensé grâce à des cibles de référence, supposées fixes. Ce mouvement, la **pose de la caméra** (`pan`, `tilt`, `rotation` en degrés, `scale`, `sigma0` du recalage, dans `camera/`), se lit avant les capteurs : il explique une grande part de ce qui bouge sur les courbes (D-073). Ce skill dit comment lire les données d'une station : ce que montrent les courbes et les images, moment par moment. Il ne dit pas ce qu'elles veulent dire : catégorie, event connu, hypothèse et verdict sont l'affaire de celui qui t'appelle.
## À lire d'abord
- `labeling/connaissances/colonnes-des-deplacements.md` : formats des exports et sens des colonnes (**en premier**) ;
- `labeling/connaissances/les-trous.md` ;
- sur une station dont l'export porte les métriques de qualité d'image (`peak` à `snr` : la ligne « Qualité d'image de l'export » d'`inventaire.py`), `labeling/connaissances/metriques-de-qualite.md`.
## Les outils
Lance-les depuis la racine du dépôt. Ils rendent des valeurs, jamais des verdicts : c'est toi qui juges.
| Commande | Ce qu'elle rend |
|---|---|
| `python3 agent-tools/inventaire.py <dossier> [--debut T] [--fin T] [--fichiers]` | Fichiers par type (au-delà de 5 par type : le nombre, le premier et le dernier ; `--fichiers` pour la liste complète, à n'utiliser que pour chercher un fichier précis), **ce que contient chaque source** sur la fenêtre (colonnes de l'export, de la pose et de `quality/`, avec le nombre de lignes qui ont une valeur, « vide » sinon ; noms des métriques système de `metrics/` ; images et images différentielles ; des noms et des comptes, jamais de valeurs), images : par suites d'écarts égaux entre deux images (à 5 min près, sur la fenêtre si elle est donnée ; une ligne par changement d'écart : un trou se date par ses deux images), poses de la caméra (nombre, période, instants de mesure sans recalage), période, cadence, mesures manquantes, capteurs (référence ou cible, seuil d'erreur, mesures rejetées) : ces comptes portent sur **toute la période**. Avec `--debut`/`--fin` (sur un lot : ceux du lot), une section de plus pour la fenêtre : les pas absents datés (pour tous les capteurs, ou lesquels manquent), par capteur, les mesures rejetées datées (suites de pas consécutifs), puis le **nombre de références retenues par la compensation** (`inlier` = 1) à chaque instant et les suites datées où des références ne le sont pas, lesquelles et pourquoi (`r` rejetée, `0` écartée par la compensation, `vide`). Une mesure est rejetée quand son `error_value` dépasse le seuil du capteur, **références comprises**. Quand `pattern_type` est vide, un capteur est une référence s'il porte `reproj_err` ou `inlier` (la ligne « pattern_type vide pour N capteurs » le dit) ; une colonne de l'export que tous les capteurs ne portent pas dit combien la portent. Quand `inlier` est vide sur la fenêtre, les références retenues sont lues sur `reproj_err` rempli (le titre le dit) ; une marque autre que `r` ou `vide` est la valeur d'`inlier` (ex. `-1`). « Relevés en double » : un export (souvent nommé d'après le projet du client) dont les relevés sont déjà dans les autres ; avec 0 valeur différente, il ne change rien à la lecture, sinon les outils gardent celui du dernier fichier dans l'ordre des noms. Une suite qui finit le même jour n'écrit que l'heure de sa fin. La ligne « Qualité d'image de l'export (peak à snr) » dit si les six métriques de qualité sont remplies (alors `qualite.py`) ou vides. Sur un mois, la sortie avec `--debut`/`--fin` dépasse ce qu'un appel affiche : lis chaque section par un tube vers `grep` (ex. `| grep -A40 '^Références retenues'`, `| grep '^ PR04 '`) |
| `python3 agent-tools/resume.py <dossier> [--colonne C] [--stat median\|min\|max] [--pas 1h] [--niveau periode\|fenetre] [--capteurs A,B] [--debut T] [--fin T] [--instants T1,T2] [--marque]` | Niveau habituel de chaque capteur (médiane, MAD, min, max) sur toute la période, ou sur la fenêtre `--debut`/`--fin` avec `--niveau fenetre` (pour un lot : un changement de niveau dans le lot ne se compare pas à des semaines d'autres mesures), puis un tableau par pas de temps. Colonnes : `error_value`, `corr_x`, `corr_y`, `relative_x`, `relative_y`, `x`, `y`, `sigma0`, `reproj_err`, et les six métriques de qualité d'image `peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr` (valeurs brutes ; face à une référence calme, `qualite.py`). L'en-tête des capteurs se répète toutes les 24 lignes. `--marque` : `*` après la valeur quand une mesure du pas est rejetée (`x`, `y`, `error_value` d'une mesure rejetée restent remplis), `o` quand une mesure du pas a inlier = 0. `--instants T1,T2` : seulement les pas qui contiennent ces instants (les valeurs de tous les capteurs à quelques heures choisies). Avec `--pas` égal à la cadence, `--niveau fenetre --marque`, c'est la table par instant et par capteur d'une colonne : une colonne par lancement |
| `.venv/bin/python agent-tools/graphique.py <dossier> [--capteurs A,B] [--colonnes C1,C2] [--debut T] [--fin T] [--zone T1/T2 ...] [--sortie D]` | Un PNG des séries ; chaque `--zone` est grisée ; il imprime son chemin. Colonnes : celles de `resume.py`, métriques de qualité comprises (valeurs brutes). **Regarde-le avec Read** : tu lis mieux un graphique qu'un tableau |
| `.venv/bin/python agent-tools/ensemble.py <dossier> [--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5] [--residus corr_x,corr_y,error_value|non] [--hors T1/T2] [--autres] [--rigide BASE [--sans A,B] [--suivre A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut T] [--fin T] [--sortie D]` | Tous les capteurs ensemble, chacun face à sa médiane et sa MAD sur la fenêtre. Deux PNG : **commun** (médiane entre capteurs de `x`, `y`, `sigma0` : avec la dispersion entre capteurs en bande grise ; sur les panneaux `x`, `y`, en plus, **chaque référence globale à part** (un trait chacune) et la **médiane des cibles seules** (trait noir) ; et, à chaque pas, le nombre de capteurs dont `--colonne` dépasse sa médiane de plus de `--k` MAD ; en tête, si le dossier a `camera/`, la **pose de la caméra**, valeurs brutes, un point par recalage, le trait coupé aux instants de mesure sans recalage) et **multiples** (un petit graphique par capteur, une échelle chacun : un palier d'un seul capteur s'y voit). Imprime aussi la **table de la médiane commune** (une ligne par pas de `--pas` : l'heure et l'écart à la médiane de la fenêtre de `x`, `y`, `sigma0`, puis `x_cibles`, `y_cibles` (médiane des cibles seules), puis la pose brute de la caméra, colonnes `cam_pan`, `cam_tilt`, `cam_rotation`, `cam_scale`, `cam_sigma0`, vides sans recalage) avec le minimum et le maximum de chaque colonne et leur instant, puis ceux de `x`, `y` de chaque référence globale (marqués `(rejetée)` quand la mesure l'est, avec le nombre de mesures rejetées de la référence), puis les instants de mesure sans pose (suites datées), puis les instants où au moins `--min` capteurs dépassent ensemble, avec leurs noms. Trois PNG de plus, **residus-corr_x**, **residus-corr_y**, **residus-error_value** (`--residus`) : un petit graphique par capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre ; avec `--hors T1/T2`, celle du reste de la fenêtre, hors du moment lu), une échelle chacun, zéro en pointillé : un écart de quelques centièmes sur `corr`, caché dans les bandes parallèles de `graphique.py`, s'y voit ; imprime pour chaque capteur le niveau, le bruit propre (médiane des écarts entre deux mesures) et l'écart min/max par pas avec leur instant, en unités et en bruits ; `--residus non` : aucun de ces PNG ni de ces tables. Avec `--autres`, des PNG **residus-…-autres** de plus : chaque capteur moins sa propre médiane **et moins la médiane des autres capteurs au même instant** (ce que tous partagent, le reste de la compensation d'un mouvement commun, s'annule ; ce qui est propre reste), et, par capteur, la pente et la corrélation r de ce résidu sur la médiane commune de `x`, `y`, `sigma0` : un creux qui reste après `--autres` n'est pas un reste partagé par tous ; une pente élevée avec r proche de ±1 sur `y` commun dit qu'il est proportionnel au mouvement commun (gain propre au capteur), sans r ni pente il est indépendant du mouvement. Avec `--rigide BASE`, un PNG **rigide** de plus : à chaque mesure, le mouvement d'ensemble des cibles depuis l'instant `BASE` (translation, rotation, échelle, estimé par médianes : une cible qui saute seule ne le tire pas ; `--sans A,B` en retire des cibles), et, pour chaque capteur, le **résidu** `dx`, `dy` (position brute moins sa position à `BASE` transportée par ce mouvement, en px) ; panneaux : `dx`, `dy` de chaque référence globale face à la médiane et au 10e-90e centile des cibles, `|résidu|` des cibles (médiane, 90e centile), rotation et échelle ajustées, `reproj_err` des références ; imprime la table au pas (`rot_deg`, `echelle`, `tx`, `ty`, `cib_med`, `cib_max`, `dx`, `dy` de chaque référence, et de chaque capteur de `--suivre A,B` : la suite pas à pas d'une cible) et, par capteur, min, max et valeur au dernier instant de `dx`, `dy`. Les mesures rejetées n'entrent ni dans l'ajustement, ni dans la bande des cibles, `cib_med`, `cib_max`, ni dans les colonnes de la table : sur plusieurs jours, des voitures garées ou des rejets de nuit ne noient plus le reste ; sur le PNG, une référence rejetée est une croix (l'échelle est celle des mesures acceptées, une croix loin est hors cadre) ; le résumé par capteur les donne à part (`; N rejetées : min …, max …`, et `(rejetée)` après une dernière valeur rejetée). Contrairement à l'écart à la médiane, ce résidu ne dépend pas de la place du capteur dans l'image quand la scène tourne ou change d'échelle. Les tables par pas (médiane commune, `--rigide`) répètent leur en-tête toutes les 24 lignes ; `--table T1/T2` ne les imprime qu'entre T1 et T2 (`non` : pas du tout), niveaux, min, max, PNG et le reste restant sur toute la fenêtre : sur un lot d'un mois, lis d'abord avec `--table non`, puis relance avec `--table` sur le jour d'un moment (mêmes niveaux, ce que ne donnerait pas une fenêtre `--debut`/`--fin` plus courte). Les graduatioLine truncated
| `python3 agent-tools/plages.py <dossier> [--colonnes error_value,corr_x,corr_y] [--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N] [--capteurs A,B] [--debut T] [--fin T]` | Par colonne et par capteur, aux mesures (pas natif, jamais moyennées) : niveau (médiane de la fenêtre), bruit propre, **plus grand saut** d'une mesure à la suivante (valeur, en bruits, les deux instants) ; puis les **plages** où le capteur s'écarte de son niveau de plus de `--k` bruits : début, fin, nombre de mesures, extrême (signé, en unités et en bruits) et son instant ; deux plages du même sens à moins de `--fusion` n'en font qu'une, les mesures rejetées ne coupent pas une plage ; colonne `rejetées` : combien des mesures de la plage le sont (et `extrême rejetée`), `(rejetée : …)` après un plus grand saut dont un bout l'est. Sert à dater le début et la fin d'un moment d'un capteur sans relancer dix tableaux. Un bruit `0` (et « - » en bruits, aucune plage) : les valeurs sont constantes à l'arrondi près (écarts sous 1e-9), comme le `corr` des références quand la compensation n'en retient que deux (voir Conventions) ; même chose dans `ensemble.py --residus` et `jours.py`. Quand un épisode long fausse la médiane de la fenêtre (le capteur y passe la moitié du lot), `--hors T1/T2` calcule niveau et bruit hors de l'épisode ; une plage qui touche le bord de la fenêtre est datée au bord. `--min-mesures N` n'imprime que les plages d'au moins N mesures (et dit combien sur le total) : sur un lot de plusieurs jours, les plages d'un pas se comptent par centaines et noient les paliers longs ; lis d'abord avec `--min-mesures 6`, puis sans. `--glissant N` (N mesures de part et d'autre) ou `--glissant 1d` (les mesures à moins d'une durée) : le niveau de chaque mesure est la médiane de ses voisines, sans elle ; une dérive longue ou un palier suivent ce niveau local, seuls restent les écarts plus brefs que la fenêtre (la colonne niveau du tableau et le bruit ne changent pas ; avec `--hors`, seul le bruit se calcule hors de l'épisode). `--instants N` : à la fin, les instants où au moins N capteurs sont hors niveau sur l'une des colonnes, avec chaque capteur et son écart signé en bruits (`cx` corr_x, `cy` corr_y, `ev` error_value), les capteurs rejetés à cet instant (parmi `--capteurs` : en retirer les capteurs toujours rejetés allège la liste), et chaque référence : `error_value` (`r` si rejetée) / inlier |
| `.venv/bin/python agent-tools/jours.py <dossier> [--colonnes corr_x,corr_y,error_value] [--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes [--lissage N] [--fraction F]] [--debut T] [--fin T] [--sortie D]` | Ce qui revient d'un jour à l'autre, sur les mesures acceptées seulement. 1. **Niveau de chaque nuit** (heures `--nuit` H1-H2 UTC, à cheval sur minuit, datée du jour où elle commence), par capteur et par colonne : médiane, MAD, nombre de mesures, et le bruit propre ; puis, d'une nuit à la suivante, la **marche** (différence des médianes, en unités et en bruits) et **où elle se place** (« entre A et B » : là où la suite des mesures de nuit des deux nuits se coupe le mieux entre les deux niveaux ; B au début de la nuit suivante : la coupure tombe de jour, entre les deux nuits). Une marche de quelques bruits, une dérive d'une nuit à l'autre, et deux colonnes qui marchent au même instant s'y lisent, même quand le capteur a plusieurs niveaux dans le lot. 2. **Jours superposés** : PNG **parheure-<colonne>**, un petit graphique par capteur, en abscisse l'heure du jour, une courbe par jour, chaque mesure moins le niveau de la dernière nuit commencée (nuit grisée, cadre du 1er au 99e centile, le titre dit combien de mesures sortent du cadre) ; table : par créneau de `--pas` de l'heure du jour, les capteurs dont l'écart dépasse `--k` bruits, du même côté, au moins `--jours` jours, avec le nombre de jours et la médiane de ces écarts. Ce qui revient chaque jour à la même heure, sur un capteur ou plusieurs, s'y groupe, même quand cela ne dure qu'une à trois mesures. 3. **Bornes de chaque jour**, avec `--bornes` : pour la médiane des cibles de chaque colonne et pour la pose de la caméra (`pan`, `tilt`, `rotation`, `scale`, `sigma0`, si `camera/` existe), l'écart au niveau de la nuit qui précède chaque jour (un jour va de la fin d'une nuit à la fin de la suivante ; avec `--capteurs`, la médiane de ces capteurs, avec un seul, le sien). Par jour : nombre de mesures, la première et la dernière ; premier et dernier instant au-delà de `--k` bruits, avec la mesure juste avant et juste après, au pas natif ; max et min signés avec leur instant ; la suite de mesures au-delà de `--k` bruits qui entoure le plus grand des deux ; la nuit suivante moins la nuit de référence. Un jour sans mesure le dit ; une nuit de référence qui n'est pas la précédente est nommée. Chaque ligne de jour commence par le nom court de sa suite (`corr_x`, `pose_tilt`…) : sur un mois, `| grep '^pose_tilt '` en lit une, `| grep ' 12/10 '` un jour. `--lissage N` : l'écart de chaque mesure est la médiane des N mesures du jour centrées sur elle (bruit et `--k` inchangés ; PNG : lissé en bleu, brut en gris) : un point isolé ne coupe plus la suite autour de l'extrême et ne fait plus un premier ou un dernier dépassement. `--fraction F` : le seuil de chaque jour est F fois le plus grand |écart| de ce jour (imprimé sur sa ligne, `seuil …`), au lieu de `--k` bruits : quand le bruit au pas natif est sans rapport avec l'ampleur du cycle (pose très bruitée, ou très lisse). PNG **bornes** : l'écart sur le lot, premier → dernier dépassement grisé clair, suite autour de l'extrême grisée foncé, max et min marqués. Le choix de `--nuit` : des heures où le cycle du jour (`error_value`, pose de la caméra) est retombé. **Regarde les PNG avec Read** |
| `.venv/bin/python agent-tools/metriques.py <dossier> [--noms A,B] [--pas 1h] [--stat median\|min\|max] [--contre temperature] [--lissage 24h] [--metriques-seules] [--debut T] [--fin T] [--sortie D]` | Les métriques système de `metrics/` (une valeur par heure), jamais les identifiants (`SIM_CCID`, `ip*`). Imprime les métriques disponibles avec leur nombre de valeurs sur la fenêtre (« vide » : aucune), puis une table par pas de `--pas` : `temperature` (médiane des composants `sensor_*_deg_c`, celle que lisent les détecteurs), chaque métrique de `--noms` (défaut : les `*_deg_c` et `BusVoltage`), puis, sauf `--metriques-seules`, `cib_corr_x`, `cib_corr_y` (médiane sur les cibles de `corr` moins le niveau propre de chaque cible, mesures acceptées) et la pose brute de la caméra (`cam_pan` … `cam_sigma0`) ; une case vide est sautée, une métrique texte (`link`, `BatteryState`, `last_sync`) est rendue telle quelle. Puis, par colonne : pas remplis, min et max avec leur instant ; la corrélation r et la pente de chaque colonne sur `--contre` (avec `--lissage 24h`, sur sa moyenne glissante, colonne `<contre>_lisse`) ; les suites datées de pas sans aucune métrique. Un PNG : températures sur un panneau (médiane en noir), chaque autre métrique sur le sien, puis `cib_corr_x`, `cib_corr_y` et la pose, trait coupé sur un trou. **Regarde-le avec Read** |
| `.venv/bin/python agent-tools/stations.py <dossier> <dossier> [...] [--colonnes temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y] [--pas 1h] [--stat median\|min\|max] [--table T1/T2\|non] [--debut T] [--fin T] [--sortie D]` | **Plusieurs stations sur une même ligne de temps** (stations voisines, même bâtiment). Colonnes possibles : `temperature` (comme `metriques.py`), `cam_pan` … `cam_sigma0` (pose brute), `cib_corr_x`, `cib_corr_y` (comme `metriques.py`), `rej_cibles`, `rej_refs` (nombre de cibles, de références rejetées, le plus grand du pas). Imprime par station la période, la cadence et le nombre d'instants ; puis les **trous** : les suites de pas sans mesure ou sans température, avec les stations où elles manquent (un trou commun à plusieurs stations sur une seule ligne) ; puis la table par pas (une colonne `STATION:colonne` chacune, tabulations ; `--table` comme `ensemble.py`) ; puis, par colonne et par paire de stations, r des valeurs et r des pas d'une valeur à la suivante (un mouvement commun se voit sur les pas, une tendance commune sur les valeurs), avec n. PNG **stations** : un panneau par colonne, un trait par station (température brute, le reste moins sa médiane), et une bande par station des pas sans mesure. Prends `--pas` égal à la cadence la plus lente des stations ; sur un mois à `1h`, lis d'abord avec `--table non`. **Regarde-le avec Read** |
| `python3 agent-tools/qualite.py <dossier> [--calme T1/T2,T3/T4] [--commun] [--table M] [--pas 15min] [--seuil 0.5] [--capteurs A,B] [--debut T] [--fin T]` ; `... --etiquettes F [--numeros 3,7] [--marge 60] [--bords]` ; `... --etiquettes F --hors [--min 1] [--sauf "Thermal displacement"]` ; `.venv/bin/python agent-tools/qualite.py <dossier> --figure [--metriques flux,snr,dominance] [--etiquettes F] [--zone T1/T2 ...] [--sortie D]` ; `python3 agent-tools/qualite.py --essai` | Les six **métriques de qualité d'image** (`peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr` ; définitions : `labeling/connaissances/metriques-de-qualite.md`), sur les stations qui les ont (sinon : « Aucune métrique de qualité », et rien d'autre). Chaque mesure devient un **rapport** à la **référence calme** de son capteur : la médiane de la métrique sur ses mesures des fenêtres `--calme`, à la même heure UTC du jour (sans `--calme` : tout le dossier) ; 1 = comme la référence, < 1 plus bas, > 1 plus haut ; pour `fwhm` et `dominance`, c'est la hausse qui dit une image dégradée ; mesures rejetées comprises. Sans option : le `peak` maximal du dossier, puis par capteur (`r` = référence) les mesures rejetées, `pk/max` (peak médian sur la fenêtre divisé par ce maximum : à 1, la tache touche le plafond de l'image, son `peak` ne bouge plus et sa `sharpness` suit l'exposition : lis plutôt `flux`, `snr`), et pour chaque métrique le rapport médian et l'extrême avec son instant ; puis la médiane des cibles et des références. `--commun` : par pas, la médiane des rapports des cibles / des références pour chaque métrique (ce qui touche toute la scène, visibilité ou turbulence ; `--pas 1d` pour voir en un écran sur quels jours la référence tient). `--table M` : par pas, le rapport de `M` de chaque capteur (`*` : une mesure rejetée), leur médiane et combien passent `--seuil` (sous, ou au-dessus de 1/`--seuil` pour `fwhm`, `dominance`) : une cible qui s'éteint et revient. `--etiquettes F` (un JSON par ligne, `debut`, `fin`, `categorie`) : par étiquette numérotée, le rapport médian des cibles et des références sur l'heure d'avant, la plage et l'heure d'après (`cib 0.96\|0.26\|0.79`, `--marge` minutes), puis les capteurs **touchés** sur la plage (flux ou snr sous `--seuil`, ou dominance au-dessus de 1/`--seuil`), avec leur pire flux, du plus bas au plus haut ; `--bords` : par instant de la plage élargie, le nombre de capteurs touchés et la médiane des cibles de flux, snr, dominance (`<` dans la plage), pour dater le premier et le dernier instant dégradé. `--hors` : les suites d'instants qu'aucune étiquette ne couvre (hors familles `--sauf`) où au moins `--min` capteurs sont touchés, avec les capteurs et leur pire flux : des candidats aux étiquettes oubliées, à vérifier sur `corr_x`, `corr_y`. `--figure` (au lieu des tables) : PNG **qualite-commun** (un panneau par métrique, échelle log : médiane des cibles en noir, des références en rouge, bande grise du 10e au 90e centile des cibles : une gêne de toute la scène déplace la médiane, une occultation de quelques cibles ne déplace que le bas de la bande) et un PNG **qualite-<métrique>** par `--metriques` (un petit graphique par capteur, références en rouge) ; `--etiquettes` y grise chaque étiquette d'une couleur par famille, `--zone` des plages. **Regarde les PNG avec Read** |
| `.venv/bin/python agent-tools/vignettes.py <dossier> --capteurs A,B --heures T1,T2 [--rayon 100] [--contraste [MIN,MAX]] [--fixe] [--zone X,Y,L,H] [--sortie D]` | Une planche de vignettes à pleine résolution : une ligne par capteur, une colonne par heure, centrées sur la position brute (`x`, `y`) du capteur à chaque heure (le centre du cadre est écrit sous chaque vignette : quand `x`, `y` sautent, le cadre se déplace d'autant, et une tache qui entre dans le cadre semble apparaître) ; `--fixe` garde pour chaque capteur le cadre de la première heure et marque d'une croix rouge les `x`, `y` de chaque heure ; pixels non retouchés, l'éclat se compare d'une vignette à l'autre ; imprime pour chaque vignette le fond (médiane), le 99e centile et le pic (niveaux de gris 0 à 255) ; sans image à l'heure demandée, prend la plus proche et imprime l'écart (l'heure réelle est dans le titre). Une tache faible ou déformée est invisible telle quelle : `--contraste MIN,MAX` met toutes les vignettes en gris avec le même étirement (sans valeur : du 1er centile au maximum de la planche, écrasé par un pixel saturé ; choisis alors MIN,MAX d'après le fond et le pic imprimés, ex. `10,40`), `--rayon 30` à `50` grossit ; compare la forme et le pic avant, pendant et après un épisode, à la même heure de la journée. **Regarde-la avec Read** : une image entière lue par Read est réduite, un petit réflecteur y devient illisible. Un cadre que le bord de l'image coupe est signalé (« cadre coupé par le bord de l'image (L × H px) ») : sur certaines stations, `x`, `y` ne sont pas des pixels (valeurs proches de 0) et le cadre tombe dans le coin ; regarde alors la scène par `--zone`. `--zone X,Y,L,H` (pixels de l'image d'origine : coin haut gauche, largeur, hauteur, comme `gif.py`) : la même zone à chaque heure, côte à côte (jusqu'à 4 par ligne), même étirement avec `--contraste` ; `--capteurs` devient facultatif, et ceux qui sont donnés sont marqués d'une croix et de leur nom. Pour la scène autour des cibles (objet au premier plan, phares, éclairage), préfère-la à un grand `--rayon`. Chaque vignette est rendue un pixel pour un pixel jusqu'à 1000 px de côté, mais Read réduit un PNG large : avec un grand `--rayon` ou une grande `--zone`, trois ou quatre heures par planche |
| `.venv/bin/python agent-tools/gif.py <dossier> --debut T --fin T [--largeur 720] [--duree 700] [--max 150] [--zone X,Y,L,H] [--sortie D]` | Un GIF des images de la caméra entre `--debut` et `--fin` inclus, recadrées au besoin sur `--zone`, mises à `--largeur` px, date et heure UTC écrites en bas à droite ; au-delà de `--max` images, `--max` à intervalle régulier ; imprime l'heure de chaque image, puis le chemin et la taille du GIF. Sert à joindre la scène à une réponse au client ; Read ne lit pas un GIF : pour regarder, `vignettes.py --zone` |
| `ls <dossier>/images/ \| grep <AAAAMMJJ>T<HHMM>Z`, puis Read sur le fichier trouvé (Read ne prend pas de motif) | L'image entière de la caméra à cette heure (UTC), pour la scène (occultation, éclairage, météo) |
`--sortie <dossier>` : là où celui qui t'appelle range tes figures ; il te le donne.
## Conventions
- Instants : `2026-01-01T00:00Z` ; une heure sans fuseau est lue en UTC ; `--fin` inclut la minute indiquée. Sur un lot, `--debut` et `--fin` du lot.
- Bash ne sert qu'à lancer ces outils, `ls`, `grep` et `date`, une commande par appel, sans boucle `for` (un tube vers `grep` est permis) : les permissions sont accordées commande par commande. Si le répertoire courant n'est pas la racine du dépôt, `cd <racine> && <commande>` compte pour une commande. N'écris aucun autre script. Celui qui t'appelle peut ajouter des commandes à cette liste.
- **Une sortie trop longue pour un appel** (au-delà de quelques centaines de lignes, coupée à l'affichage) : raccourcis-la d'abord par les options de l'outil (`--table non` puis `--table T1/T2`, `--min-mesures`, `--capteurs`, `--colonnes`, une fenêtre plus courte), ou lis-en une section par un tube vers `grep` (`| grep -A40 '^Titre'`, `| grep '^pose_tilt '`). Si tu dois la relire plusieurs fois, range-la dans le dossier de sortie dans le même appel (`<commande> > <sortie>/<nom>.txt`) et lis ce fichier par Read (`offset`, `limit`) ou par `grep` : pas de `head`, `tail`, `sed`, `cut`. Les outils créent eux-mêmes leur dossier de sortie : pas de `mkdir`.
- Un nom de capteur qui porte une apostrophe (`COLH20'''`, `REFP''21`) se met entre guillemets doubles dans le shell : `--capteurs "COLH20'''",COLI22`.
- Chaque PNG se regarde avec Read : un PNG que tu n'as pas regardé n'a rien montré.
- **Métriques de qualité d'image** (`qualite.py`) : elles disent **pourquoi** une mesure se dégrade, là où `error_value` dit seulement qu'elle se dégrade ; elles prouvent une cause et nomment les cibles touchées. Ce qu'elles ont montré sur LENZSPITZE (à confirmer sur chaque station) : `flux` coupé (près de 0) sur un groupe de cibles, les autres intactes, le temps d'une à quelques mesures : ces cibles sont cachées (la liste se lit sur le flux à chaque fois, pas sur la liste habituelle ; une cible cachée peut rester sous son seuil d'erreur, et son point est faux) ; `flux` en baisse sur toute la scène, plus fort sur les cibles lointaines : visibilité réduite ; `sharpness` en baisse et `dominance` en hausse, `flux` entier : l'image tremble (turbulence) ; rien ne bouge : ni l'image ni la vue, à chercher dans le mouvement. Un flux entier dément une occultation. `fwhm`, tronquée au disque, bouge peu ; sur une tache au plafond (`pk/max` à 1), elle baisse quand la tache s'assombrit. **La référence calme décide de tout** : prends `--calme` sur des heures calmes du **même régime de l'image** que la plage lue. Quand l'éclairage ou l'exposition change (après un trou, une intervention), une référence de l'autre côté fausse les rapports d'un facteur deux ou trois : `--commun --pas 1d` sur le lot montre ce changement (médianes des cibles et des références loin de 1 des jours entiers, puis à 1) ; prends alors une référence de chaque côté et lis chaque côté avec la sienne. Les jours calmes sont souvent des jours de cycle thermique : une lecture du thermique contre eux est circulaire.
- Une mesure rejetée (`error_value` au-dessus du seuil) n'est pas une mesure : la station vide les `corr` d'une cible rejetée, mais laisse ceux d'une **référence** rejetée, souvent absurdes ; les outils les vident (`corr`, plages, résidus, sauts ne portent que sur les mesures acceptées). Quand la compensation ne retient que **deux références**, leur `corr` vaut 0 (à 1e-13 près) : elle passe exactement par elles ; leur bruit s'imprime `0` et leurs écarts en bruits « - » ; ne lis rien dans ces valeurs, lis les références par `x`, `y` (`ensemble.py --rigide`) et `error_value`. Ses `x`, `y` restent : avant de citer un saut de `x`, `y`, regarde s'il est marqué `(rejetée)` ; une mesure rejetée ne se cite pas comme un mouvement.
## La méthode
1. **Inventaire** : ce qui est disponible, ce qui manque (fichiers, ce que contient chaque source, images, poses de la caméra, période, cadence, capteurs). Une colonne remplie que les outils ne montrent pas ou une source qu'aucun outil ne lit (`images_diff/`) reste une donnée : sache qu'elle existe. Les six colonnes de qualité d'image (`peak` à `snr`), remplies sur les caméras récentes, se lisent par `qualite.py`. `metrics/` se lit par `metriques.py` : une coupure des mesures se lit face aux pas sans métrique et à la tension (`--noms BusVoltage,BusCurrent,Power,BatteryPercent --metriques-seules` sur la coupure) ; des métriques toutes vides (« vide » sur chaque nom) sont une donnée absente, pas une température stable. Sur un lot, relance-le avec `--debut`/`--fin` du lot : les pas absents et les rejets du lot, datés ; ceux de la période entière ne disent rien du lot. Lis les rejets des **références** autant que ceux des cibles : un capteur rejeté aux mêmes heures chaque jour fait un moment à lui seul (dis sa part de mesures rejetées et ses heures, jour par jour) ; quand c'est une référence, dis avec combien de références la compensation tourne alors (la liste des références retenues). Quand plusieurs cibles sautent ensemble d'un pas, ou que la compensation tombe (pas de pose), regarde d'abord dans cette liste quelles références ont été perdues à cet instant.
2. **Large d'abord** : `ensemble.py` sur le lot, d'abord (sur un lot de plus de quelques jours, avec `--table non`, puis `--table T1/T2` sur les jours à lire) ; **la pose de la caméra en premier** (panneaux du haut, colonnes `cam_` de la table) : quand la caméra tourne (`pan`, `tilt`, `rotation`), change d'échelle (`scale`), quand son recalage se dégrade (`sigma0`) et quand elle n'est pas recalée (trait coupé, instants sans pose), datés au pas natif ; chaque moment des capteurs se lit ensuite face à elle : pendant un mouvement ou un trou de recalage, ou caméra immobile. La pose est calculée à partir des références globales : un changement de pose (ou une montée de `sigma0`) ne se lit comme un mouvement de la caméra que si **les cibles bougent aussi dans l'image** ; regarde, sur les panneaux `x`, `y`, les traits des références face au trait noir des cibles seules (et la colonne `x_cibles`, `y_cibles` de la table). Si seules des références bougent dans l'image et que les cibles restent immobiles, ce sont ces références qui ont bougé : la pose et les `corr` de toutes les cibles en sont faussés, sans mouvement brut des cibles ; dis quelles références et de combien. Si tout bouge ensemble, références et cibles, c'est la caméra ou la scène ; regarde alors si les `corr` reviennent. Dès que la pose tourne ou change d'échelle, l'écart à la médiane ne dit plus qui bouge seul (chaque capteur s'en écarte selon sa place dans l'image) : avant d'écrire « tout bouge ensemble », relance avec `--rigide BASE`, `BASE` un instant calme avant le premier mouvement, et lis le PNG **rigide** et sa table : une référence dont le résidu reste loin du 10e-90e centile des cibles, ou un `reproj_err` des références qui ne revient pas, veut dire que la compensation reste faussée par ces références et que les paliers de `corr` en viennent en partie ; dis lesquelles, de combien, jusqu'à quand ; un `|résidu|` des cibles qui monte dit qu'elles ne bougent pas comme un bloc. Puis la médiane de `x`, `y` (position brute, références comprises), les références une à une, les cibles seules et `sigma0` disent ce qui bouge dans l'image, avant de lire `corr` ; lis la table imprimée (heure, valeur) pour dater le début, la fin et le retour du mouvement et pour voir un niveau qui ne revient pas, et ne les devine pas sur l'axe du PNG : un creux de `corr` qui suit un mouvement de la médiane brute est le reste de la compensation, pas un mouvement propre des capteurs touchés ; les petits multiples d'`error_value` montrent un palier durable d'un capteur, le compte les instants où beaucoup de capteurs montent ensemble. Sur tout lot, sans attendre un soupçon, regarde les PNG **residus** (`corr_x`, `corr_y`, `error_value`) : chaque capteur face à son propre niveau, c'est là que se voient un capteur seul qui monte ou descend, un `corr` qui dérive de quelques centièmes, un palier propre à un capteur sous un mouvement commun ; la table dit de combien (en bruits) et quand. Pour séparer, sur une cible dont `corr` baisse sous un mouvement commun fort, un reste de compensation d'un mouvement propre, relance avec `--autres` (le reste partagé disparaît, la pente sur `x`, `y` commun dit s'il est proportionnel). Sur un lot de plus de deux jours, lance ensuite `jours.py` (avant de lire les pas isolés de `plages.py`) : ce qui revient chaque jour à la même heure se lit d'abord sur ses PNG **parheure** et sa table par créneau, et fait un moment par heure du jour (dis quels capteurs, combien de jours sur combien, l'ampleur, ce que fait la pose de la caméra à cette heure-là), pas un moment par jour ni rien du tout parce que chaque pas est court ; puis lis sa table des **niveaux de nuit**, pour tout capteur qui a déjà fait un palier ou dont `--hors` ne suffit pas (plusieurs niveaux dans le lot) : chaque marche d'une nuit à l'autre se date par son « entre A et B », et une marche d'`error_value` et une de `corr` au même instant se relient ; une dérive lente se lit d'une nuit à l'autre. Pour ce qui revient chaque jour et s'étiquette jour par jour (cycle thermique, réchauffement et refroidissement), relance `jours.py --bornes` plutôt que de fixer les mêmes heures pour tous les jours : chaque jour se date sur sa ligne, la suite autour de l'extrême pour le cycle, le max et le min pour un aller et un retour (le matin et l'après-midi) ; les mesures « avant » et « après » donnent les bornes au pas natif (à une cadence de 1 h ou de 4 h, un événement va de la mesure d'avant à celle d'après). Prends `--nuit` sur des heures où la pose et `error_value` sont retombées (figure **parheure**) : si le premier dépassement tombe au début du jour (« avant - ») et le dernier à sa fin chaque jour, la nuit choisie n'est pas calme ; change `--nuit` ou passe à `--capteurs` pour les cibles qui portent le cycle. Quand la caméra dérive toute la nuit, prends une nuit courte juste avant le matin (`--nuitLine truncated
3. **Puis zoome** : `resume.py` à 15min (`--stat max` pour le pic réel d'un capteur), et `graphique.py` sur les fenêtres et les capteurs qui bougent.
4. **Chaque capteur face à son propre niveau habituel** (sa médiane et sa MAD), jamais à un seuil absolu ; sur un lot, le niveau se calcule sur le lot (`--niveau fenetre`, `ensemble.py`), pas sur la période entière.
5. **Chaque moment retenu se date et se mesure au pas natif de 15 min** : début, fin et maximum lus sur la table à 15 min (`ensemble.py` par défaut, `resume.py --pas 15min`), jamais sur un tableau à l'heure ; lis aussi `ensemble.py --min 1` pour les capteurs seuls, et `plages.py` sur le lot (d'abord avec `--min-mesures 6`) pour avoir, par capteur, début, fin, extrême et plus grand saut au pas natif (relance-le avec `--hors` autour d'un épisode long pour dater son retour au niveau, ne conclus pas « ne revient pas » sans l'avoir lu ; quand le lot a une dérive longue ou plusieurs paliers (les plages se comptent par centaines, ou une moitié du lot est « hors niveau »), relance-le avec `--glissant` (quelques mesures, ou une durée de quelques heures à un jour selon la cadence) et `--instants 2` : les écarts brefs sous la dérive sortent seuls, et la liste par instant dit quels capteurs s'écartent ensemble, lesquels sont rejetés et ce que font les références à cet instant ; un écart de toutes les cibles avec les références au même instant se lit face à la pose de la caméra), et les tables de `x`, `y` sur les fenêtres où ils s'agitent. Sur une station qui a les métriques de qualité, pour chaque moment : `qualite.py --table flux --capteurs …` (ou `--etiquettes F --numeros N --bords` sur une étiquette) dit quelles cibles sont cachées (flux coupé) ou voilées, de quel instant à quel instant ; écris-les par leur nom.
6. **Les images** : vignettes (avec `--contraste` pour une cible faible) espacées, une toutes les 2 à 3 h, plus serrées là où les courbes bougent, toujours avec un capteur témoin non touché, à une heure avant, pendant et après (à la même heure de la journée si possible) ; quand `x`, `y` d'un capteur sautent entre deux vignettes (centre du cadre écrit sous chacune), relance avec `--fixe` avant de dire qu'une tache apparaît ou disparaît ; l'image entière pour la scène (occultation, éclairage, météo).
## Ce que la lecture rend
Une ligne par moment. Un moment : un capteur ou un groupe de capteurs qui sort de son niveau habituel pendant une fenêtre que tu peux dater.
| Début | Fin | Capteurs | Colonnes | Ce que je vois | Images |
|---|---|---|---|---|---|
- **Capteurs** : références ou cibles, combien, lesquels.
- **Ce que je vois** : la forme (pic d'un pas, palier, montée lente, agitation), l'ampleur face au niveau habituel (en MAD ou en fois la médiane), le retour à la normale ou non, ce que font les autres capteurs, **ce que fait la caméra** au même moment (pose qui bouge, de combien, ou immobile ; recalage absent ; « pas de `camera/` » si le dossier n'en a pas).
- **Images** : ce que montrent les vignettes et l'image entière à ce moment, ou « pas d'image ».
Heures en UTC.
+4
View File
@@ -4,5 +4,9 @@ __pycache__/
app/web/node_modules/
app/web/dist/
labeling
detectors
.env
/out/
tools
agents
optimizer
-4
View File
@@ -1,4 +0,0 @@
[submodule "detectors"]
path = detectors
url = gitea@exchange.sensima.ch:maxime.pasquier/detectors.git
branch = main
+2 -2
View File
@@ -3,9 +3,9 @@
"tasks": [
{
"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",
"detail": "Prepares .venv and the front end if needed, then launches the server on http://127.0.0.1:8770 (links data, labeling, detectors, tools, agents and optimizer: README.md)",
"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 -r app/requirements.txt; }; } && (cd app/web && { [ -d node_modules ] || npm install; } && npm run build) && .venv/bin/python app/serveur/serveur.py",
"command": "{ [ -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/server/server.py",
"isBackground": true,
"problemMatcher": []
}
+16 -15
View File
@@ -1,19 +1,20 @@
# 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/<STATION>/`, un lien vers `~/aimsight-data/data`, rempli par le pompage de ce dépôt) 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: the control station of the AIMsight diagnostic (`README.md`): the web app, and the launching of processes whose code lives elsewhere. A camera follows targets on a structure; the detectors read the displacement series of the stations and flag the moments when the curves must not be trusted (rain, fog, spider web, turbulence…) or a real movement. The architecture of the repositories: `docs/architecture.drawio`.
- **Les processus** : l'onglet Analysis lance l'`analyste` sur une plage (étiquettes et rapport dans `labeling/auto/analyses/<STATION>_<début>_<fin>/`, versées dans `labeling/auto/<STATION>.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 `<analyse>/detectors/<heure>/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). `labeling/` est un lien vers le dépôt `~/labeling`, partagé avec Optimizer : on y commite les étiquettes, pas ici.
- **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/<STATION> --labels labeling/auto/<STATION>.jsonl --from AAAA-MM-JJ --to AAAA-MM-JJ` (`--to` exclu).
- **Le pompage** : dans `~/aimsight-data` (`extraction/pomper.sh`, tâches VS Code **pomper**, **pomper une plage**), en lecture seule sur la plateforme ; mode d'emploi `~/aimsight-data/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).
- **The processes**: the Analysis tab launches `agents:analyst` (plugin `agents/`) on a range, with `instructions/analyst.md` and `DETECTORS: no` (labels and report in `labeling/auto/analyses/<STATION>_<start>_<end>/`, submitted to `labeling/auto/<STATION>.jsonl`); "Optimize the detectors" launches `/improve` in `optimizer/` (its request in `app/server/analysis.py`, its summary in `optimizer/sessions/<analysis>_<time>/summary.md`), which commits in `detectors/`, then `agents:tool-builder`, which commits in `tools/`.
- **The links** (ignored by git, one copy of each repository on the workstation): `data/`, `labeling/`, `detectors/`, `tools/`, `agents/`, `optimizer/`; each thing is committed in its own repository, never here. This repository carries no agent, no reading tool, no workflow.
- **The truth**: the labels of `labeling/auto/`; the labeling knowledge is in `labeling/`.
- **The contracts**: with the detectors, `detectors/CLAUDE.md` (`categories.events`, `bench/score.py`); with the agents, `agents/README.md` (the requests of the analyst and of the tool-builder); with Optimizer, `optimizer/README.md` (the request of `/improve`). A renaming over there requires the change here. The Data page passes to the detectors the measurements read by `tools/scripts/data.py`, whereas the benchmark and Optimizer read through `detectors/scripts/data.py`: a reading fix in one is carried over to the other.
- **The benchmark**: `python3 detectors/bench/regression.py --labels labeling/auto --data data` (~3 min); the score of a range: `python3 detectors/bench/score.py data/<STATION> --labels labeling/auto/<STATION>.jsonl --from YYYY-MM-DD --to YYYY-MM-DD` (`--to` excluded).
- **The pumping**: in `~/aimsight-data` (`extraction/pump.sh`, VS Code tasks **pump**, **pump a range**), read-only on the platform; user guide `~/aimsight-data/extraction/README.md`. Claude may launch it on small ranges; a long range or a history, outside busy hours.
- **Check a change of the app**: `.venv/bin/python app/server/check.py`, then `cd app/web && npm run build` and launch the server. The labels: `python3 labeling/validate.py`.
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/`, 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.
Rules:
- Every time is in UTC.
- No rule specific to a station, a target or a date.
- Read-only on `data/`, except the pumping; never copy the identifiers of the metrics (`SIM_CCID`, `ip*`).
- Never read `.env` (the credentials of the platform).
- The agents run on the Claude subscription, never on an API key.
- Commits by path, never `git add -A`: another session may be working in this repository.
- Language: the repository (documents, code, UI) in English; conversations with the user in French.
+36 -32
View File
@@ -1,50 +1,54 @@
# Diagnostic-app
La web app de diagnostic AIMsight : la page Data (courbes, images de la caméra, étiquettes, événements des détecteurs) et son onglet Analysis, qui lance par `claude -p` :
The control station of the AIMsight diagnostic: see, analyze, launch. The Data page shows the curves, the camera images, the labels and the detectors' events; its Analysis tab launches, by `claude -p`, processes whose code lives in the other repositories:
- l'`analyste`, sur une plage choisie (« Analyser la plage ») : un rapport de diagnostic et des étiquettes ;
- « Optimiser les détecteurs », sur une analyse finie : `/detectors:wf-improve` (le plugin du dépôt detectors) améliore les détecteurs sur la plage de l'analyse, ses étiquettes pour vérité, sans sur-apprentissage, contrôlé par le benchmark de toutes les étiquettes ; puis le `tool-builder` fait entrer les scripts de l'analyste dans les outils de lecture.
- **"Analyze the range"**: the `analyst` of the agents repository, on a chosen range, with the app's instructions (`instructions/analyst.md`) and without the detectors (`DETECTORS: no`): labels, submitted to `labeling/auto/`, and a diagnostic report;
- **"Optimize the detectors"**, on a finished analysis: `/improve` in Optimizer improves the detectors on the range of the analysis, its labels as truth, without overfitting; then the `tool-builder` of the agents repository brings the analyst's scripts into the reading harness (tools repository).
## Le dépôt
The architecture of the repositories, one responsibility each: `docs/architecture.drawio`.
- `app/` : la web app (serveur FastAPI, page React et Mantine) ; sa doc dans `app/README.md`.
- `.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/` : un lien vers le dépôt `~/labeling`, partagé avec Optimizer (on y commite les étiquettes) : le savoir du labeling (`regles-d-etiquetage.md`, `familles.md`, `carte-des-etiquettes.md`, `connaissances/`), les étiquettes (`auto/<STATION>.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 (voir plus bas).
- `data/` : un lien vers `~/aimsight-data/data`, les données des stations, **hors de git**, un dossier par station (`displacement/`, `metrics/`, `camera/`, `images/`).
## The repository
## Les détecteurs (`detectors/`)
- `app/`: the web app (FastAPI server, React and Mantine page); its doc in `app/README.md`.
- `instructions/analyst.md`: what the app asks of the analyst (output folder, report, dialogue).
- `docs/`: the architecture of the repositories, the plans.
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 :
And six links, ignored by git, to the neighbouring repositories (a single copy of each on the workstation):
- 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/<STATION>.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, `<analyse>/detectors/<heure>/` (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.
| Link | Repository | What the app does with it |
|---|---|---|
| `data/` | `~/aimsight-data/data` | reads the data of the stations (outside git) |
| `labeling/` | `~/labeling` | reads and writes the labels; the analyses go in `labeling/auto/analyses/` |
| `detectors/` | `~/detectors` | reads the detectors' events (`scripts/categories.py`) |
| `tools/` | `~/tools` | reads the data through `tools/scripts/data.py`; the analyst uses it, the tool-builder writes in it |
| `agents/` | `~/agents` | the plugin of the agents (`--plugin-dir agents`, `--agent agents:analyst`) |
| `optimizer/` | `~/Optimizer` | launches `/improve` there; reads the summaries in `optimizer/sessions/` |
Mettre à jour les détecteurs : `git -C detectors pull`, puis `git commit -m "..." -- detectors`.
Each thing is committed in its own repository: the labels in `~/labeling`, the detectors in `~/detectors` (the optimization session does it, without pushing), the tools in `~/tools` (the tool-builder does it).
## 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 les liens vers les données et les étiquettes : `ln -s ~/aimsight-data/data data` et `ln -s ~/labeling labeling` (les dépôts aimsight-data et labeling, clonés à côté).
À la main :
## Install and launch
```bash
git submodule update --init && git -C detectors checkout -B main
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
ln -s ~/aimsight-data/data data && ln -s ~/labeling labeling && ln -s ~/detectors detectors
ln -s ~/tools tools && ln -s ~/agents agents && ln -s ~/Optimizer optimizer
```
La page s'ouvre sur `http://127.0.0.1:8770`. `claude` (Claude Code, connecté) doit être sur le `PATH` pour l'onglet Analysis.
The VS Code task **Run app** creates `.venv` and builds the front end if they are missing, then launches the server. By hand:
## Pomper les données
```bash
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/server/server.py
```
Le pompage est dans le dépôt `~/aimsight-data` (`extraction/`, tâches VS Code **pomper** et **pomper une plage**) ; mode d'emploi `~/aimsight-data/extraction/README.md`.
The page opens on `http://127.0.0.1:8770`. `claude` (Claude Code, logged in to the subscription) must be on the `PATH` for the Analysis tab.
## Vérifier
## Pump the data
- 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`.
The pumping is in the `~/aimsight-data` repository (`extraction/`, VS Code tasks **pump** and **pump a range**); user guide `~/aimsight-data/extraction/README.md`.
## Check
- the app: `.venv/bin/python app/server/check.py`;
- the labels: `python3 labeling/validate.py` (the labels submitted by the app do not have `review` yet, which it requires: as many expected errors);
- the detectors (benchmark, ~3 min): `python3 detectors/bench/regression.py --labels labeling/auto --data data`.
-162
View File
@@ -1,162 +0,0 @@
"""Lecture des données d'une station pour l'agent de diagnostic (bibliothèque standard).
Formats : labeling/connaissances/colonnes-des-deplacements.md. Toute heure est en UTC.
"""
import csv
import glob
import os
import re
import statistics
from datetime import datetime, timezone
# Colonnes numériques de l'export « advanced » ; une case vide devient None.
NUM = ("x", "y", "error_value", "error_threshold", "relative_x", "relative_y",
"corr_x", "corr_y", "reproj_err", "inlier", "sigma0",
"peak", "flux", "sharpness", "fwhm", "dominance", "snr") # qualité de l'image : caméras récentes seulement (LENZSPITZE)
# Pose de la caméra (camera/, pompage) : pan, tilt, rotation [deg], scale, sigma0 (résidu du recalage).
POSE = ("pan", "tilt", "rotation", "scale", "sigma0")
IMAGE_RE = re.compile(r"^(\d{8}T\d{4})Z_")
def _entete(chemin):
with open(chemin, newline="") as f:
return next(csv.reader(f), [])
def trouver(dossier):
"""Dossier de station -> {'advanced', 'horaire', 'camera', 'images', 'autres'} : chemins triés, sous-dossiers compris."""
out = {"advanced": [], "horaire": [], "camera": [], "images": [], "autres": []}
for p in sorted(glob.glob(os.path.join(dossier, "**", "*"), recursive=True)):
if os.path.isdir(p) or "images_diff" in p.split(os.sep): # images différentielles du pompage (--diff) : pas des vues de la caméra
continue
entete = _entete(p) if p.endswith(".csv") else []
if p.lower().endswith((".jpg", ".jpeg", ".png")):
out["images"].append(p)
elif "sensor_name" in entete and "corr_x" in entete: # quality/ (optical_emulator) a sensor_name, pas corr_x
out["advanced"].append(p)
elif "timestamp" in entete:
out["horaire"].append(p)
elif "median_pan" in entete:
out["camera"].append(p)
else:
out["autres"].append(p)
return out
def _nombre(v):
v = v.strip()
return float(v) if v else None
def charger(dossier):
"""Exports « advanced » du dossier -> {capteur: [mesure]}, triées par t, un seul relevé par instant.
Mesure : dict avec t (datetime UTC), pattern_type, et les colonnes de NUM (float ou None).
Une mesure rejetée (voir rejetee) a corr_x, corr_y vides, comme le dit la doc des colonnes : la station
les vide pour une cible, mais en laisse de remplis (souvent absurdes) pour une référence ; on les vide ici.
"""
par = {}
for chemin in trouver(dossier)["advanced"]:
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
m = {c: _nombre(r.get(c) or "") for c in NUM} # inlier manque dans les exports anciens
m["t"] = instant(r["time_utc"])
m["pattern_type"] = r["pattern_type"]
if rejetee(m):
m["corr_x"] = m["corr_y"] = None
par.setdefault(r["sensor_name"].strip(), {})[m["t"]] = m # certains exports finissent le nom par un saut de ligne
return {s: [d[t] for t in sorted(d)] for s, d in par.items()}
def charger_temperature(dossier):
"""Températures de la carte de la station (metrics/, sensor_*_deg_c) -> [(t, °C)] triées : la médiane des composants à
chaque heure ; [] sans ces métriques. Les composants montent et descendent ensemble (l'étiqueteur lit « les
températures de tous les composants ») ; la médiane écarte la pointe d'un seul, le GPU qui calcule (D-124)."""
par = {}
for chemin in glob.glob(os.path.join(dossier, "metrics", "*_deg_c_*.csv")):
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
if (v := _nombre(r.get("metric") or "")) is not None:
par.setdefault(instant(r["time_utc"]), []).append(v)
return [(t, statistics.median(v)) for t, v in sorted(par.items())]
def charger_camera(dossier):
"""Mouvements de la caméra du dossier -> [pose] triées par t ; pose : t et les colonnes de POSE (float ou None).
Une ligne par recalage de la caméra ; on lit les médianes (min = max dans les fichiers reçus : une mesure par minute).
Un instant de mesure sans pose : la caméra n'a pas été recalée.
"""
par = {}
for chemin in trouver(dossier)["camera"]:
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
p = {c: _nombre(r.get("median_" + c, "")) for c in POSE}
p["t"] = instant(r["time_utc"])
par[p["t"]] = p
return [par[t] for t in sorted(par)]
IDENTIFIANTS = re.compile(r"^(SIM_CCID|ip(_.*)?)$") # identifiants de la station : jamais lus
METRIQUE_RE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
def charger_metriques(dossier):
"""Métriques de la station (metrics/, un CSV par métrique et par jour) -> {nom: [(t, valeur)]} triées : les
valeurs numériques seulement (BusVoltage, sensor_CPU_deg_c, rsrp_dBm…) ; les métriques texte (link, mode…) et les
identifiants (SIM_CCID, ip*) ne sont pas lus. Nom : celui du fichier, sans la station ni la date."""
# ponytail: les métriques texte sont sautées ; les lire (link up/down) quand un détecteur en a besoin
station, par = os.path.basename(os.path.normpath(dossier)) + "_", {}
for chemin in glob.glob(os.path.join(dossier, "metrics", "*.csv")):
if not (m := METRIQUE_RE.match(os.path.basename(chemin))):
continue
nom = m.group(1).removeprefix(station)
if IDENTIFIANTS.match(nom):
continue
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
try:
v = float((r.get("metric") or "").strip("[]'\" ")) # certaines métriques arrivent en liste : ['-95']
except ValueError:
continue
par.setdefault(nom, {})[instant(r["time_utc"])] = v
return {n: sorted(d.items()) for n, d in sorted(par.items())}
def est_reference(mesures):
"""Référence du réseau de compensation (pattern_type global_ref), sinon cible. Certains exports ont pattern_type vide,
sur toute la période ou au début : on lit alors le premier pattern_type rempli et, s'il n'y en a aucun, reproj_err
ou inlier remplis (références seulement : labeling/connaissances/colonnes-des-deplacements.md)."""
t = next((m["pattern_type"] for m in mesures if m["pattern_type"]), None)
if t is not None:
return t == "global_ref"
return any(m["reproj_err"] is not None or m["inlier"] is not None for m in mesures)
def rejetee(m):
"""Mesure rejetée par la station : error_value au-dessus du seuil du capteur (error_threshold) ; sans ces deux valeurs, corr_x vide."""
if m["error_value"] is not None and m["error_threshold"] is not None:
return m["error_value"] > m["error_threshold"]
return m["corr_x"] is None
def filtrer(mesures, debut, fin):
"""Mesures entre debut et fin inclus, à la minute près (comme iso() les affiche) ; None = pas de borne."""
return [m for m in mesures if (debut is None or m["t"] >= debut)
and (fin is None or m["t"].replace(second=0, microsecond=0) <= fin)]
def heure_image(chemin):
"""'20261013T1200Z_10167931.jpg' -> datetime UTC ; None si le nom ne suit pas ce format (D-045)."""
m = IMAGE_RE.match(os.path.basename(chemin))
return datetime.strptime(m.group(1), "%Y%m%dT%H%M").replace(tzinfo=timezone.utc) if m else None
def instant(texte):
"""'2026-01-01T00:00Z' ou '2026-01-01 00:00' -> datetime UTC ; une heure sans fuseau est lue en UTC."""
t = datetime.fromisoformat(texte)
return t.astimezone(timezone.utc) if t.tzinfo else t.replace(tzinfo=timezone.utc)
def iso(t):
return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
-491
View File
@@ -1,491 +0,0 @@
"""Vue d'ensemble de tous les capteurs d'un export « advanced » : ce que font les capteurs ensemble.
Usage : .venv/bin/python agent-tools/ensemble.py data/PS_DES_COUDRES/
[--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5]
[--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--rigide BASE [--sans A,B] [--suivre A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
Chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane et MAD de la fenêtre).
Deux PNG, dont les chemins sont imprimés :
1. « commun » : d'abord, si le dossier a des mouvements de la caméra (camera/), un panneau par grandeur de la pose
(pan, tilt, rotation [deg], scale, sigma0 du recalage), valeurs brutes, un point par recalage ; puis un panneau par colonne de --colonnes (défaut x,y,sigma0 : position brute et sigma0 de la
caméra) : médiane, sur les capteurs, de l'écart de chaque capteur à sa médiane ; bande grise = 10e à 90e
centile entre capteurs (la dispersion) ; sur chaque panneau sauf sigma0, en plus, chaque référence globale à part
(son écart à sa médiane, un trait par référence) et la médiane des cibles seules (trait noir) : on voit si les
références bougent dans l'image avec les cibles ou sans elles ; dernier panneau : nombre de capteurs dont --colonne
(défaut error_value) dépasse sa médiane de plus de --k MAD à chaque pas.
2. « multiples » : un petit graphique par capteur (références d'abord) de --colonne, médiane par pas de --pas,
trait pointillé = médiane de la fenêtre ; chaque graphique a son échelle, un palier se voit.
3. « residus-<colonne> » (un PNG par colonne de --residus, défaut corr_x,corr_y,error_value) : un petit graphique par
capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre, ou hors de --hors T1/T2 si
donné : le niveau est alors celui du reste de la fenêtre, pas celui du moment lu), une échelle par capteur, zéro en
pointillé ; un écart de quelques centièmes sur une colonne `corr` que les bandes parallèles de `graphique.py` cachent
s'y voit. Imprime, par capteur, le niveau, le bruit propre (médiane des écarts entre deux mesures consécutives) et
l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits
(bruit 0 et « - » en bruits : valeurs constantes à l'arrondi près, 1e-9 ; --residus non : aucun PNG de résidus).
Avec --autres, chaque capteur est de plus ramené à l'écart à la médiane des AUTRES capteurs au même instant (on
retranche, à chaque mesure, la médiane des autres capteurs de la même colonne moins leur niveau propre) : ce qui est
partagé par tous (le reste de la compensation d'un mouvement commun) s'annule, ce qui est propre au capteur reste.
PNG « residus-<colonne>-autres » ; la table imprime en plus, par capteur, la pente de ce résidu sur chaque
colonne de --colonnes (médiane commune, ex. y) et la corrélation r : un résidu proportionnel au mouvement commun
(même s'il n'est pas partagé par tous) a une pente non nulle et un r élevé.
4. « rigide » (avec --rigide BASE) : à chaque mesure, le mouvement d'ensemble des cibles depuis l'instant BASE
(similitude : translation, rotation, échelle, estimée par médianes sur les cibles, hors --sans) ; pour chaque
capteur, le résidu dx, dy = position brute moins sa position à BASE transportée par ce mouvement [px]. Panneaux :
dx et dy de chaque référence globale (un trait chacune) face à la médiane et au 10e-90e centile des cibles ;
médiane et 90e centile de |résidu| des cibles ; rotation et échelle ajustées ; reproj_err des références. Imprime
la table par pas de --pas (rot_deg, echelle, tx, ty, cib_med, cib_max, puis dx, dy de chaque référence et de chaque
capteur de --suivre A,B), puis par capteur le min et le max de dx, dy avec leur instant et la valeur au dernier
instant. Les mesures rejetées n'entrent ni dans l'ajustement, ni dans la bande et la médiane des cibles, cib_med,
cib_max, ni dans les colonnes de la table ; sur le PNG, celles des références sont des croix, qui ne fixent pas l'échelle ; dans le résumé par
capteur, elles viennent à part (nombre, min et max).
Imprime aussi la table de la médiane commune (une ligne par pas de --pas : heure, écart à la médiane de la fenêtre
pour chaque colonne de --colonnes, puis <colonne>_cibles, la médiane des cibles seules, puis la pose brute de la caméra, vide sans recalage) puis le minimum et le maximum de chaque colonne avec leur instant, et ceux de chaque référence globale ; pour dater
un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence des mesures ; un pas plus large,
1h par ex., aplatit un pic d'un à quatre pas et date à l'heure).
Imprime aussi, pour chaque instant où au moins --min capteurs dépassent leur médiane de plus de --k MAD,
le nombre et les capteurs (--min 1 : aussi les instants où un seul capteur sort de son niveau), et les instants de
mesure sans pose de la caméra (pas de recalage).
Les tables par pas (médiane commune, --rigide) répètent leur en-tête toutes les 24 lignes. Avec --table T1/T2, elles ne
s'impriment qu'entre T1 et T2 (« non » : pas du tout) ; niveaux, minimum et maximum, PNG et le reste portent toujours sur
toute la fenêtre --debut/--fin : sur un mois, on lit tout le reste, puis la table d'un jour aux mêmes niveaux.
Rend des valeurs, pas de verdict.
"""
import argparse
import math
import os
import statistics
import sys
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates # noqa: E402
import matplotlib.pyplot as plt # noqa: E402
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
from graphique import COLONNES, RACINE, borne # noqa: E402
from resume import bruit_propre, duree # noqa: E402
def niveau(ms, col):
"""(médiane, MAD) des valeurs non vides ; None si aucune."""
v = [m[col] for m in ms if m[col] is not None]
if not v:
return None
med = statistics.median(v)
return med, statistics.median(abs(x - med) for x in v)
def similitude(p, q):
"""Similitude (a, b, tx, ty) qui envoie les points p sur q : q ≈ (a·x − b·y + tx, b·x + a·y + ty).
Estimation par médianes (une cible qui saute seule ne tire pas l'ajustement) : rotation et échelle, médiane sur
toutes les paires de cibles du rapport complexe (qi − qj) / (pi − pj) ; translation, médiane de q − (rotation, échelle)·p.
"""
p, q = [complex(*u) for u in p], [complex(*u) for u in q]
z = [(q[i] - q[j]) / (p[i] - p[j]) for i in range(len(p)) for j in range(i) if p[i] != p[j]]
r = complex(statistics.median(v.real for v in z), statistics.median(v.imag for v in z))
d = [w - r * u for u, w in zip(p, q)]
return r.real, r.imag, statistics.median(v.real for v in d), statistics.median(v.imag for v in d)
def rigide(o, noms, series, temps, base, station):
"""4. Chaque capteur face au mouvement d'ensemble des cibles depuis l'instant --rigide : PNG « rigide » et table."""
t_b = min(temps, key=lambda t: abs(t - o.rigide))
pos = {s: {m["t"]: (m["x"], m["y"]) for m in series[s] if m["x"] is not None and m["y"] is not None} for s in noms}
sans = set(o.sans.split(",")) - {""}
acc = {s: {m["t"] for m in series[s] if not rejetee(m)} for s in noms} # mesures acceptées : seules à entrer dans l'ajustement et les statistiques des cibles
refs = [s for s in noms if series[s] and est_reference(series[s])]
cib = [s for s in noms if s not in refs and t_b in pos[s]]
ajust = [s for s in cib if s not in sans and t_b in acc[s]]
suivis = [s for s in o.suivre.split(",") if s and s not in refs]
res, fit = {s: {} for s in noms}, {} # res : {capteur: {t: (dx, dy)}} ; fit : {t: (rotation deg, échelle, tx, ty, |r| médiane, max des cibles)}
for t in temps:
ok = [s for s in ajust if t in pos[s] and t in acc[s]]
if len(ok) < 2:
continue
a, b, tx, ty = similitude([pos[s][t_b] for s in ok], [pos[s][t] for s in ok])
for s in noms:
if t in pos[s] and t_b in pos[s]:
(x0, y0), (x, y) = pos[s][t_b], pos[s][t]
res[s][t] = (x - (a * x0 - b * y0 + tx), y - (b * x0 + a * y0 + ty))
r = [math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]]
fit[t] = (math.degrees(math.atan2(b, a)), math.hypot(a, b), tx, ty, statistics.median(r), max(r))
if not fit:
print(f"\n--rigide : moins de deux cibles avec x, y à {iso(t_b)} et ensuite.")
return
tf = sorted(fit)
reproj = {s: {m["t"]: m["reproj_err"] for m in series[s] if m["reproj_err"] is not None} for s in refs}
panneaux = [("dx", 0), ("dy", 1)]
fig, axes = plt.subplots(6, 1, sharex=True, figsize=(14, 18), squeeze=False)
for ax, (nom, k) in zip(axes[:2, 0], panneaux):
band = [sorted(res[s][t][k] for s in cib if t in res[s] and t in acc[s]) for t in tf]
q = [statistics.quantiles(v, n=10, method="inclusive") if len(v) >= 2 else [v[0]] * 9 for v in band]
ax.fill_between(tf, [x[0] for x in q], [x[-1] for x in q], color="0.85", label="cibles : 10e-90e centile")
ax.plot(tf, [statistics.median(v) for v in band], "-", lw=1.2, color="k", label="cibles : médiane")
for i, s in enumerate(refs):
ta = [t for t in res[s] if t in acc[s]]
ax.plot(ta, [res[s][t][k] for t in ta], "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
cadre = ax.get_ylim() # l'échelle des mesures acceptées : une référence rejetée loin est hors cadre
for i, s in enumerate(refs):
tr = [t for t in res[s] if t not in acc[s]]
if tr: # mesures rejetées : à part, une croix chacune, hors du trait
ax.plot(tr, [res[s][t][k] for t in tr], "x", ms=3, color=f"C{(i + 1) % 10}", label=f"{s} rejetée")
ax.set_ylim(cadre)
ax.set_ylabel(f"{nom} [px]\nposition brute moins\nle mouvement des cibles")
ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4)
axes[2, 0].plot(tf, [fit[t][4] for t in tf], "-", lw=1, color="k", label="cibles : médiane de |résidu|")
p90 = {t: statistics.quantiles([math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]], n=10, method="inclusive")[-1] for t in tf}
axes[2, 0].plot(tf, [p90[t] for t in tf], "-", lw=0.8, color="C3", label="cibles : 90e centile de |résidu| (le max est dans la table)")
axes[2, 0].set_ylabel("|résidu| des cibles [px]")
axes[2, 0].legend(loc="upper left", fontsize=8)
axes[3, 0].plot(tf, [fit[t][0] for t in tf], "-", lw=1, color="C2")
axes[3, 0].set_ylabel("rotation ajustée [deg]")
axes[4, 0].plot(tf, [fit[t][1] for t in tf], "-", lw=1, color="C2")
axes[4, 0].set_ylabel("échelle ajustée")
for i, s in enumerate(refs):
axes[5, 0].plot(list(reproj[s]), list(reproj[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
axes[5, 0].set_ylabel("reproj_err\ndes références")
if refs:
axes[5, 0].legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4)
for ax in axes[:, 0]:
ax.grid(alpha=0.4)
ax.axvline(t_b, color="C3", ls=":", lw=0.8)
axes[-1, 0].set_xlim(tf[0], tf[-1])
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
fig.suptitle(f"{station} : mouvement d'ensemble (translation, rotation, échelle) ajusté sur {len(ajust)} cibles depuis {iso(t_b)} (pointillé), "
"résidu de chaque capteur, mesures acceptées (croix : référence rejetée) (heures UTC)")
fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight()))
chemin = base.format("rigide")
fig.savefig(chemin, dpi=100, bbox_inches="tight")
plt.close(fig)
print(chemin)
print(f"\nMouvement d'ensemble ajusté sur les cibles depuis {iso(t_b)} : {', '.join(ajust)}"
+ (f" (hors ajustement : {', '.join(sorted(sans & set(cib)))})" if sans & set(cib) else "")
+ f".\nRésidu = position brute moins la position de {iso(t_b)} transportée par ce mouvement [px] ; mesures rejetées hors de l'ajustement, "
f"de cib_med, cib_max et des colonnes des capteurs (à part dans le résumé par capteur) ; médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
cols = ["rot_deg", "echelle", "tx", "ty", "cib_med", "cib_max"] + [f"{s}_{c}" for s in refs + suivis for c in ("dx", "dy")]
minuit = tf[0].replace(hour=0, minute=0, second=0, microsecond=0)
t0 = minuit + ((tf[0] - minuit) // o.pas) * o.pas
par_pas = {}
for t in tf:
ligne = par_pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {})
for c, v in zip(cols, fit[t]):
ligne.setdefault(c, []).append(v)
for s in refs + suivis:
if t in res[s] and t in acc[s]:
ligne.setdefault(f"{s}_dx", []).append(res[s][t][0]), ligne.setdefault(f"{s}_dy", []).append(res[s][t][1])
w = max(10, max(len(c) for c in cols) + 1)
entete = f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols)
for i, t in enumerate(t for t in sorted(par_pas) if o.dans_table(t)):
if i % 24 == 0:
print(entete)
print(f"{iso(t):17}" + "".join(f"{statistics.median(par_pas[t][c]):{w}.{7 if c == 'echelle' else 3}g}" if c in par_pas[t] else " " * w for c in cols))
print("\nPar capteur, mesures acceptées : min et max de dx, dy, valeur au dernier instant ; puis les rejetées à part :")
for s in noms:
bons = {t: v for t, v in res[s].items() if t in acc[s]}
rej = {t: v for t, v in res[s].items() if t not in acc[s]}
for k, c in ((0, "dx"), (1, "dy")):
ligne = f"{s:9}{' (réf.)' if s in refs else ' '} {c}"
if bons:
lo, hi = min(bons.items(), key=lambda x: x[1][k]), max(bons.items(), key=lambda x: x[1][k])
der = res[s].get(tf[-1])
ligne += (f" min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}, au dernier instant "
f"{der[k] if der else math.nan:+.3g}{' (rejetée)' if der and tf[-1] not in acc[s] else ''}")
else:
ligne += " aucune mesure acceptée"
if rej:
lo, hi = min(rej.items(), key=lambda x: x[1][k]), max(rej.items(), key=lambda x: x[1][k])
ligne += f" ; {len(rej)} rejetées : min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}"
if bons or rej:
print(ligne)
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--colonnes", default="x,y,sigma0")
a.add_argument("--colonne", default="error_value", choices=COLONNES)
a.add_argument("--pas", default="15min", type=duree, help="pas des tables et des courbes en bleu (défaut 15min, la cadence des mesures : un pas plus large aplatit et décale les événements courts)")
a.add_argument("--k", type=float, default=5, help="écart compté, en MAD de la fenêtre")
a.add_argument("--min", type=int, default=5, help="nombre de capteurs à partir duquel un instant est imprimé")
a.add_argument("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur (« non » ou '' : aucune)")
a.add_argument("--hors", help="T1/T2 : le niveau propre des résidus se calcule hors de ce moment")
a.add_argument("--autres", action="store_true", help="résidus de plus ramenés à la médiane des autres capteurs au même instant, avec pente et corrélation sur le mouvement commun")
a.add_argument("--rigide", type=instant, metavar="BASE", help="résidus face au mouvement d'ensemble des cibles (translation, rotation, échelle) depuis l'instant BASE")
a.add_argument("--sans", default="", help="A,B : cibles laissées hors de l'ajustement de --rigide (leur résidu reste tracé)")
a.add_argument("--suivre", default="", help="A,B : avec --rigide, dx, dy de ces capteurs ajoutés à la table au pas (les références y sont déjà)")
a.add_argument("--table", default="", metavar="T1/T2|non",
help="tables par pas imprimées seulement entre T1 et T2 (« non » : pas du tout) ; le reste sur toute la fenêtre")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
o = a.parse_args()
par = charger(o.dossier)
if not par:
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
colonnes = o.colonnes.split(",")
residus = [c for c in o.residus.split(",") if c and c != "non"] # '' ou « non » : aucune, comme --table
hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None
if hors and len(hors) != 2:
sys.exit("--hors attend T1/T2.")
if o.table in ("", "non"):
o.dans_table = lambda t: o.table == ""
else:
bornes = [instant(x) for x in o.table.split("/")]
if len(bornes) != 2:
sys.exit("--table attend T1/T2 ou non.")
o.dans_table = lambda t: bornes[0] <= t <= bornes[1]
for demandes, connus, quoi in ((noms, par, "Capteurs"), ([s for s in o.suivre.split(",") if s], noms, "Capteurs de --suivre (pris parmi --capteurs)"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")):
absents = [x for x in demandes if x not in connus]
if absents:
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
series = {s: filtrer(par[s], o.debut, o.fin) for s in noms}
if not any(series.values()):
sys.exit("Aucune mesure dans la fenêtre demandée.")
temps = sorted({m["t"] for s in noms for m in series[s]})
poses = filtrer(charger_camera(o.dossier), temps[0].replace(second=0, microsecond=0), temps[-1]) # poses à la minute, mesures à la seconde
pose_cols = POSE if poses else ()
station = os.path.basename(os.path.normpath(o.dossier))
os.makedirs(o.sortie, exist_ok=True)
base = os.path.join(o.sortie, f"{station}_{{}}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
def ecarts(col):
"""{capteur: {t: valeur - médiane de la fenêtre}}, et les MAD."""
e, mad = {}, {}
for s in noms:
n = niveau(series[s], col)
if n:
e[s] = {m["t"]: m[col] - n[0] for m in series[s] if m[col] is not None}
mad[s] = n[1]
return e, mad
# 1. commun
n_ax = len(pose_cols) + len(colonnes) + 1
fig, axes = plt.subplots(n_ax, 1, sharex=True, figsize=(14, 3 * n_ax), squeeze=False)
for ax, col in zip(axes[:, 0], pose_cols):
pose_t = {p["t"].replace(second=0, microsecond=0): p[col] for p in poses if p[col] is not None}
cam_t = sorted(set(pose_t) | {t.replace(second=0, microsecond=0) for t in temps})
# trait coupé aux instants de mesure sans recalage : il ne relie pas deux poses par-dessus un trou
ax.plot(cam_t, [pose_t.get(t, math.nan) for t in cam_t], ".-", ms=3, lw=0.5, color="C2", label="pose de la caméra (un point par recalage)")
ax.set_ylabel(f"caméra : {col}" + (" [deg]" if col in ("pan", "tilt", "rotation") else ""))
ax.legend(loc="upper left", fontsize=8)
communes, refs_par_col, ref_ecarts = {}, {}, {}
for ax, col in zip(axes[len(pose_cols):, 0], colonnes):
e, _ = ecarts(col)
med, bas, haut, tt = [], [], [], []
for t in temps:
v = sorted(e[s][t] for s in e if t in e[s])
if len(v) >= 2:
q = statistics.quantiles(v, n=10, method="inclusive")
tt.append(t), med.append(statistics.median(v)), bas.append(q[0]), haut.append(q[-1])
communes[col] = dict(zip(tt, med))
ax.fill_between(tt, bas, haut, color="0.85", label="10e-90e centile entre capteurs")
ax.plot(tt, med, ".-", ms=2, lw=0.8, label="médiane des capteurs")
refs = [s for s in e if est_reference(series[s])]
if refs and col != "sigma0": # sigma0 est le même pour tous : rien à séparer
# références globales une à une, et médiane des seules cibles : qui bouge dans l'image, les références ou tout
cib = {}
for t in temps:
v = [e[s][t] for s in e if s not in refs and t in e[s]]
if v:
cib[t] = statistics.median(v)
communes[col + "_cibles"] = cib
ax.plot(list(cib), list(cib.values()), "-", lw=1.2, color="k", label="médiane des cibles seules")
for i, s in enumerate(refs):
ax.plot(list(e[s]), list(e[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
refs_par_col[col] = refs
ref_ecarts[col] = {s: e[s] for s in refs}
ax.set_ylabel(f"{col}\nécart à sa médiane")
ax.grid(alpha=0.3)
ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs_par_col.get(col, [])) // 4)
e, mad = ecarts(o.colonne)
compte, qui = [], {}
for t in temps:
hauts = [s for s in e if t in e[s] and mad[s] > 0 and e[s][t] > o.k * mad[s]]
compte.append(len(hauts))
if len(hauts) >= o.min:
qui[t] = hauts
axes[-1, 0].step(temps, compte, where="mid", lw=0.8)
axes[-1, 0].set_ylabel(f"capteurs au-dessus\nde médiane + {o.k:g} MAD\n({o.colonne})")
axes[-1, 0].grid(alpha=0.3)
h = next((h for h in (1, 2, 3, 6, 12) if (temps[-1] - temps[0]).total_seconds() / 3600 / h <= 20), 24)
jours = (temps[-1] - temps[0]).total_seconds() / 86400
# au-delà de 20 jours, une graduation par jour se chevauche : tous les n jours, au plus 20 graduations
axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)) if h < 24 else mdates.DayLocator(interval=math.ceil(jours / 20)))
axes[-1, 0].set_xlim(temps[0], temps[-1])
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
for ax in axes[:, 0]:
ax.grid(alpha=0.5, which="major")
fig.suptitle(f"{station} : {len(e)} capteurs ensemble, chacun face à son niveau sur la fenêtre (heures UTC)")
fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight())) # place du titre
commun = base.format("commun")
fig.savefig(commun, dpi=100, bbox_inches="tight")
plt.close(fig)
print(commun)
# table de la médiane commune, par pas
minuit = temps[0].replace(hour=0, minute=0, second=0, microsecond=0)
t0 = minuit + ((temps[0] - minuit) // o.pas) * o.pas # pas calés sur l'horloge (hh:00, hh:15…), pas sur la 1re mesure
lignes_t = {}
for col in colonnes:
for t, v in communes[col].items():
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col, []).append(v)
for col in pose_cols:
communes["cam_" + col] = {p["t"]: p[col] for p in poses if p[col] is not None}
for t, v in communes["cam_" + col].items():
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault("cam_" + col, []).append(v)
for col in refs_par_col:
for t, v in communes[col + "_cibles"].items():
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col + "_cibles", []).append(v)
cols_t = colonnes + [c + "_cibles" for c in refs_par_col] + ["cam_" + c for c in pose_cols]
print(f"\nMédiane commune (écart à la médiane de la fenêtre){' et pose brute de la caméra (cam_, vide sans recalage)' if pose_cols else ''}, "
f"médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
entete = f"{'instant':17}" + "".join(f"{c:>13}" for c in cols_t)
for i, t in enumerate(t for t in sorted(lignes_t) if o.dans_table(t)):
if i % 24 == 0:
print(entete)
print(f"{iso(t):17}" + "".join(f"{statistics.median(lignes_t[t][c]):13.{6 if c.startswith('cam_') else 4}g}" if c in lignes_t[t] else " " * 13 for c in cols_t))
for col in cols_t:
if communes[col]:
lo, hi = min(communes[col].items(), key=lambda x: x[1]), max(communes[col].items(), key=lambda x: x[1])
g = 6 if col.startswith("cam_") else 4
print(f"{col} (mesures) : min {lo[1]:.{g}g} à {iso(lo[0])}, max {hi[1]:.{g}g} à {iso(hi[0])}")
for col, refs in refs_par_col.items():
print(f"\n{col} brut des références globales, écart à leur médiane de la fenêtre (mesures) ; {col}_cibles : médiane des cibles seules :")
for s in refs:
d = ref_ecarts[col][s]
lo, hi = min(d.items(), key=lambda x: x[1]), max(d.items(), key=lambda x: x[1])
rej = {m["t"] for m in series[s] if rejetee(m)}
r = lambda t: " (rejetée)" if t in rej else ""
print(f"{s:9} min {lo[1]:+.3g} à {iso(lo[0])}{r(lo[0])}, max {hi[1]:+.3g} à {iso(hi[0])}{r(hi[0])}"
+ (f" ; {len(rej)} mesures rejetées dans la fenêtre" if rej else ""))
if not pose_cols:
print("Pose de la caméra : aucune dans la fenêtre (pas de camera/ dans le dossier, ou pas de recalage).")
else:
avec = {p["t"].replace(second=0, microsecond=0) for p in poses}
suites = [] # suites d'instants de mesure consécutifs sans pose : [début, fin, nombre]
for i, t in enumerate(temps):
if t.replace(second=0, microsecond=0) in avec:
continue
if suites and suites[-1][3] == i - 1:
suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i
else:
suites.append([t, t, 1, i])
print(f"Instants de mesure sans pose de la caméra (pas de recalage) : {sum(x[2] for x in suites)} sur {len(temps)}"
+ (" : " + "; ".join(iso(a) if n == 1 else f"{iso(a)} → {iso(b)} ({n})" for a, b, n, _ in suites) if suites else ""))
# 2. petits multiples
col = o.colonne
n = len(noms)
lignes = math.ceil(n / 5)
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
for ax, s in zip(axes.flat, noms):
ms = [m for m in series[s] if m[col] is not None]
ax.plot([m["t"] for m in ms], [m[col] for m in ms], "-", lw=0.4, color="0.7")
pas = {}
for m in ms:
pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col])
ax.plot(list(pas), [statistics.median(v) for v in pas.values()], "-", lw=1.1, color="C0")
lv = niveau(series[s], col)
if lv:
ax.axhline(lv[0], color="C3", ls=":", lw=0.8)
ax.set_title(s + (" (réf.)" if series[s] and est_reference(series[s]) else ""), fontsize=9)
ax.grid(alpha=0.3)
ax.tick_params(labelsize=7)
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
for ax in list(axes.flat)[n:]:
ax.axis("off")
fig.suptitle(f"{station} : {col}, médiane par pas de {int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris), "
f"médiane de la fenêtre (pointillé) ; une échelle par capteur (heures UTC)")
fig.tight_layout()
multiples = base.format(f"multiples-{col}")
fig.savefig(multiples, dpi=100, bbox_inches="tight")
print(multiples)
# 3. résidus : chaque capteur moins son propre niveau
for col, autres in [(c, False) for c in residus] + [(c, True) for c in residus if o.autres]:
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
dev = {}
if autres: # {capteur: {t: valeur - niveau propre}} pour la médiane des autres
for q in noms:
mq = [m for m in series[q] if m[col] is not None]
rq = [m for m in mq if not hors or not hors[0] <= m["t"] <= hors[1]] or mq
nq = niveau(rq, col)
if nq:
dev[q] = {m["t"]: m[col] - nq[0] for m in mq}
print(f"\n{col} moins le niveau propre{' et moins la médiane des autres capteurs au même instant' if autres else ''} ({'hors ' + o.hors if hors else 'médiane de la fenêtre'}), médiane par pas de "
f"{int(o.pas.total_seconds() // 60)} min :")
pentes = []
print(f"{'capteur':9}{'niveau':>10}{'bruit':>10}{'écart min':>11} {'à':<17}{'(bruits)':>9}{'écart max':>11} {'à':<17}{'(bruits)':>9}")
for ax, s in zip(axes.flat, noms):
ms = [m for m in series[s] if m[col] is not None]
ref = [m for m in ms if not hors or not hors[0] <= m["t"] <= hors[1]] or ms
lv = niveau(ref, col)
if not lv:
ax.axis("off")
continue
bruit = bruit_propre([m[col] for m in ms])
if autres:
res = {}
for m in ms:
v = [dev[q][m["t"]] for q in dev if q != s and m["t"] in dev[q]]
if len(v) >= 2:
res[m["t"]] = m[col] - lv[0] - statistics.median(v)
if len(res) < 2:
ax.axis("off")
continue
else:
res = {m["t"]: m[col] - lv[0] for m in ms}
pas = {}
for t, v in res.items():
pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, []).append(v)
pm = {t: statistics.median(v) for t, v in pas.items()}
ax.plot(list(res), list(res.values()), "-", lw=0.4, color="0.7")
ax.plot(list(pm), list(pm.values()), "-", lw=1.1, color="C0")
ax.axhline(0, color="C3", ls=":", lw=0.8)
ax.set_title(s + (" (réf.)" if est_reference(ms) else "") + f" bruit {bruit:.2g}", fontsize=9)
ax.grid(alpha=0.3)
ax.tick_params(labelsize=7)
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
lo, hi = min(pm.items(), key=lambda x: x[1]), max(pm.items(), key=lambda x: x[1])
f = lambda v: f"{v / bruit:9.1f}" if bruit else f"{'-':>9}"
print(f"{s:9}{lv[0]:10.4g}{bruit:10.3g}{lo[1]:11.3g} {iso(lo[0]):<17}{f(lo[1])}{hi[1]:11.3g} {iso(hi[0]):<17}{f(hi[1])}")
if autres:
for c in colonnes:
tt = [t for t in res if t in communes[c]]
if len(tt) > 2 and len({communes[c][t] for t in tt}) > 1:
xs, ys = [communes[c][t] for t in tt], [res[t] for t in tt]
pente = statistics.linear_regression(xs, ys).slope
pentes.append(f"{s:9}pente sur {c} commun {pente:+.4g} par unité, r = {statistics.correlation(xs, ys):+.2f}")
for ax in list(axes.flat)[n:]:
ax.axis("off")
if pentes:
print("\n".join(pentes))
fig.suptitle(f"{station} : {col} moins le niveau propre{' et la médiane des autres' if autres else ''} de chaque capteur, médiane par pas de "
f"{int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris) ; une échelle par capteur (heures UTC)")
fig.tight_layout()
chemin = base.format(f"residus-{col}" + ("-autres" if autres else ""))
fig.savefig(chemin, dpi=100, bbox_inches="tight")
plt.close(fig)
print(chemin)
if o.rigide:
rigide(o, noms, series, temps, base, station)
print(f"\nInstants où au moins {o.min} capteurs ont {o.colonne} > médiane de la fenêtre + {o.k:g} MAD :")
for t, hauts in qui.items():
print(f"{iso(t)} {len(hauts):3} {','.join(hauts)}")
if not qui:
print("(aucun)")
if __name__ == "__main__":
main()
-70
View File
@@ -1,70 +0,0 @@
"""GIF des images de la caméra sur une plage, pour joindre à une réponse au client.
Usage : .venv/bin/python agent-tools/gif.py data/LENZSPITZE/
--debut 2026-10-26T18:00Z --fin 2026-10-27T08:00Z [--largeur 720] [--duree 700] [--max 150] [--zone X,Y,L,H] [--sortie DOSSIER]
Prend les images du dossier dont l'heure (nom du fichier, UTC) est entre --debut et --fin inclus, dans l'ordre, les
recadre au besoin sur --zone (pixels de l'image d'origine : coin haut gauche, largeur, hauteur), les met à --largeur px,
écrit la date et l'heure UTC en bas à droite de chacune et les ramène à 64 teintes sans tramage
(le bruit des JPEG gonfle un GIF : ~3 Mo pour une nuit d'images horaires à 720 px). Au-delà de --max images, en garde
--max à intervalle régulier. Imprime l'heure de chaque image retenue, puis le chemin du GIF et sa taille.
"""
import argparse
import os
import sys
from PIL import Image, ImageDraw, ImageFont
from donnees import heure_image, instant, iso, trouver
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--debut", required=True, help="première heure (UTC)")
a.add_argument("--fin", required=True, help="dernière heure (UTC), incluse")
a.add_argument("--largeur", type=int, default=720, help="largeur du GIF en pixels (défaut 720)")
a.add_argument("--duree", type=int, default=700, help="durée de chaque image en ms (défaut 700)")
a.add_argument("--max", type=int, default=150, help="nombre maximal d'images (défaut 150)")
a.add_argument("--zone", help="X,Y,L,H : recadrage en pixels de l'image d'origine (défaut : image entière)")
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du GIF")
o = a.parse_args()
debut, fin = instant(o.debut), instant(o.fin)
toutes = sorted((h, p) for p in trouver(o.dossier)["images"] if (h := heure_image(p)))
choisies = [(h, p) for h, p in toutes if debut <= h <= fin]
if not choisies:
dispo = f" (images du {iso(toutes[0][0])} au {iso(toutes[-1][0])})" if toutes else ""
sys.exit(f"Aucune image entre {iso(debut)} et {iso(fin)} dans {o.dossier}{dispo}.")
n = len(choisies)
if n > o.max:
choisies = [choisies[round(i * (n - 1) / (o.max - 1))] for i in range(o.max)]
print(f"{o.max} images sur {n} gardées")
vues = []
for h, p in choisies:
im = Image.open(p).convert("RGB")
if o.zone:
x, y, l, h_ = map(int, o.zone.split(","))
im = im.crop((x, y, x + l, y + h_))
im = im.resize((o.largeur, round(im.height * o.largeur / im.width)), Image.LANCZOS)
d = ImageDraw.Draw(im)
texte = h.strftime("%Y-%m-%d %H:%M UTC")
police = ImageFont.load_default(size=max(12, o.largeur // 45))
g, haut, dr, bas = d.textbbox((0, 0), texte, font=police)
x, y, marge = im.width - (dr - g) - 10, im.height - (bas - haut) - 10, 4
d.rectangle((x - marge, y - marge, x + dr - g + marge, y + bas - haut + marge), fill="black")
d.text((x - g, y - haut), texte, fill="white", font=police)
vues.append(im.quantize(64, dither=Image.Dither.NONE))
print(iso(h))
os.makedirs(o.sortie, exist_ok=True)
nom = f"images_{choisies[0][0]:%Y%m%dT%H%MZ}_{choisies[-1][0]:%Y%m%dT%H%MZ}.gif"
chemin = os.path.join(o.sortie, nom)
vues[0].save(chemin, save_all=True, append_images=vues[1:], duration=o.duree, loop=0, optimize=True)
print(f"GIF : {chemin} ({os.path.getsize(chemin) / 1e6:.1f} Mo, {len(vues)} images)")
if __name__ == "__main__":
main()
-94
View File
@@ -1,94 +0,0 @@
"""Graphique PNG des séries d'un export « advanced », pour que l'agent de diagnostic les regarde.
Usage : .venv/bin/python agent-tools/graphique.py data/PS_DES_COUDRES/
[--capteurs CAPTEUR_A,CAPTEUR_B] [--colonnes error_value,corr_x,corr_y] [--debut ...] [--fin ...]
[--zone DEBUT/FIN ...] [--sortie DOSSIER]
Un panneau par colonne, une courbe par capteur, heures UTC ; chaque --zone est grisée. Colonnes : error_value, corr_x, corr_y,
relative_x, relative_y, x, y, sigma0, reproj_err, et les six métriques de qualité d'image (peak à snr, valeurs brutes ; face à une référence calme : qualite.py).
Imprime le chemin du PNG (out/diagnostic/, ou --sortie : le dossier du rapport, pour une figure de preuve).
"""
import argparse
import os
import sys
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates # noqa: E402
import matplotlib.pyplot as plt # noqa: E402
from donnees import charger, est_reference, filtrer, instant # noqa: E402
from resume import QUALITE # noqa: E402
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err")
def zone(texte):
"""'2026-10-13T01:00Z/2026-10-13T03:00Z' -> (début, fin)."""
debut, sep, fin = texte.partition("/")
if not sep:
raise argparse.ArgumentTypeError(f"zone invalide : {texte!r} (ex. 2026-10-13T01:00Z/2026-10-13T03:00Z)")
return instant(debut), instant(fin)
def borne(t, defaut):
return t.strftime("%Y%m%dT%H%MZ") if t else defaut
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--colonnes", default="error_value,corr_x,corr_y")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--zone", type=zone, action="append", default=[], help="fenêtre à griser, DEBUT/FIN (répétable)")
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
o = a.parse_args()
par = charger(o.dossier)
if not par:
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
colonnes = o.colonnes.split(",")
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES + QUALITE, "Colonnes")):
absents = [x for x in demandes if x not in connus]
if absents:
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
series = {s: filtrer(par[s], o.debut, o.fin) for s in noms}
if not any(series.values()):
sys.exit("Aucune mesure dans la fenêtre demandée.")
vides = [c for c in colonnes if all(m[c] is None for s in noms for m in series[s])]
if len(vides) == len(colonnes):
sys.exit(f"Rien à tracer : {', '.join(colonnes)} vide(s) pour ces capteurs dans la fenêtre.")
if vides:
print(f"Panneaux vides (aucune valeur pour ces capteurs) : {', '.join(vides)}")
fig, axes = plt.subplots(len(colonnes), 1, sharex=True, figsize=(14, 3.2 * len(colonnes)), squeeze=False)
tab20 = plt.get_cmap("tab20").colors
couleurs = tab20[::2] + tab20[1::2] # teintes foncées d'abord : deux capteurs voisins ne partagent pas une teinte
for ax, col in zip(axes[:, 0], colonnes):
for i, s in enumerate(noms):
ms = series[s] # une valeur vide devient NaN : la courbe s'interrompt au lieu de relier le trou
ax.plot([m["t"] for m in ms], [float("nan") if m[col] is None else m[col] for m in ms], ".-", ms=2, lw=0.7,
color=couleurs[i % len(couleurs)], label=s)
for debut, fin in o.zone:
ax.axvspan(debut, fin, color="0.85", zorder=0)
ax.set_ylabel(col)
ax.grid(alpha=0.3)
axes[0, 0].legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
station = os.path.basename(os.path.normpath(o.dossier))
fig.suptitle(f"{station} : {', '.join(colonnes)} (heures UTC)")
os.makedirs(o.sortie, exist_ok=True)
qui = "-".join(noms) if o.capteurs else "tous"
sortie = os.path.join(o.sortie, f"{station}_{'-'.join(colonnes)}_{qui}_"
f"{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
fig.savefig(sortie, dpi=100, bbox_inches="tight")
print(sortie)
if __name__ == "__main__":
main()
-314
View File
@@ -1,314 +0,0 @@
"""Inventaire d'un dossier de station : ce qui est disponible, ce qui manque.
Usage : python3 agent-tools/inventaire.py data/PS_DES_COUDRES/ [--debut T] [--fin T] [--fichiers]
Les comptes portent sur toute la période. Avec --debut et/ou --fin, une section de plus liste, sur cette fenêtre,
les pas absents (datés, avec les capteurs qui n'ont pas de mesure) et, par capteur, les mesures rejetées (datées,
en suites de pas consécutifs ; rejetée : error_value au-dessus du seuil, références comprises), puis le nombre de
références retenues par la compensation (inlier = 1 ; inlier vide sur la fenêtre : reproj_err rempli) à chaque instant
et, datées, les suites d'instants où des références ne le sont pas (lesquelles, et pourquoi : rejetée, valeur d'inlier,
vide). Mouvements de la caméra (camera/) : nombre de poses, période, et les instants de mesure
sans pose (pas de recalage), sur toute la période puis sur la fenêtre. Avant les comptes, ce que contient chaque source
(sur la fenêtre, sinon toute la période) : les colonnes de l'export, de la pose et de quality/, remplies ou vides (avec,
pour une colonne de l'export que tous les capteurs ne portent pas, combien la portent), les noms des métriques système
de metrics/, les images et les images différentielles. Les relevés en double (même capteur, même instant dans deux
exports, ou deux fois dans un) sont comptés par export. Images : par suite d'écarts égaux entre deux images (à 5 min
près ; sur la fenêtre si elle est donnée). Une suite datée qui finit le même jour n'écrit que l'heure de sa fin.
Rend des valeurs, pas de verdict.
"""
import argparse
import collections
import csv
import glob
import os
import re
import statistics
from datetime import datetime, timedelta, timezone
from donnees import charger, charger_camera, est_reference, filtrer, heure_image, instant, iso, rejetee, trouver
from resume import QUALITE
METRIQUE_RE = re.compile(r"^(.+?)_(\d{4})_(\d{2})_(\d{2})_\d{2}_\d{2}") # NIEDERHORN_BusCurrent_2026_09_22_00_00 to ….csv
def suite(a, b, n):
"""Une suite datée : le début en entier, la fin sans la date quand elle tombe le même jour."""
if n == 1:
return iso(a)
return f"{iso(a)} → {iso(b)[11:] if iso(a)[:10] == iso(b)[:10] else iso(b)} ({n})"
def doubles(chemins):
"""Relevés (même capteur, même instant) déjà lus dans un export précédent ou plus haut dans le même : charger n'en
garde qu'un, celui du dernier fichier dans l'ordre des noms. Une ligne par export qui en a."""
vus, lignes = {}, []
for p in chemins:
n = deja = autres = 0
with open(p, newline="") as fh:
for r in csv.DictReader(fh):
n += 1
cle = (r["sensor_name"].strip(), r["time_utc"])
val = tuple(v.strip() for k, v in r.items() if k not in ("sensor_name", None))
if cle in vus:
deja += 1
autres += vus[cle] != val
vus[cle] = val
if deja:
lignes.append(f" {os.path.basename(p)} : {deja} sur {n} déjà lus, dont {autres} de valeurs différentes")
if lignes:
print("Relevés en double (même capteur, même instant dans un export déjà lu, dans l'ordre des noms ; "
"les outils gardent celui du dernier fichier) :")
print("\n".join(lignes))
def liste(chemins, tout):
"""Un dossier de pompage compte des centaines de fichiers : au-delà de 5, le premier et le dernier seulement."""
if tout or len(chemins) <= 5:
shown = chemins
else:
shown = [chemins[0], chemins[-1]]
print(f" {len(chemins)} fichiers, du premier au dernier (--fichiers pour la liste complète) :")
for p in shown:
print(f" {p}")
def fichiers(f, tout=False):
print(f"Exports « advanced » (source des mesures) : {len(f['advanced'])}")
liste(f["advanced"], tout)
doubles(f["advanced"])
print(f"Exports horaires : {len(f['horaire'])} (non lus par les outils : moyennes horaires, "
"heure locale sans fuseau ; voir labeling/connaissances/colonnes-des-deplacements.md)")
liste(f["horaire"], tout)
print(f"Mouvements de la caméra (pose à chaque recalage) : {len(f['camera'])}")
liste(f["camera"], tout)
print(f"Autres fichiers : {len(f['autres'])}")
liste(f["autres"], tout)
def remplies(chemins, debut, fin):
"""CSV d'une source -> (lignes de la fenêtre, {colonne: lignes avec une valeur}, {colonne: capteurs qui en ont une}),
colonnes dans l'ordre des en-têtes ; capteurs : sensor_name, s'il y en a."""
lignes, compte, qui = 0, {}, collections.defaultdict(set)
for p in chemins:
with open(p, newline="") as fh:
r = csv.DictReader(fh)
for c in r.fieldnames or []:
if c not in ("", "time_utc", "sensor_name"):
compte.setdefault(c, 0)
for row in r:
if (debut or fin) and filtrer([{"t": instant(row["time_utc"])}], debut, fin) == []:
continue
lignes += 1
for c in compte:
if (row.get(c) or "").strip():
compte[c] += 1
if row.get("sensor_name"):
qui[c].add(row["sensor_name"].strip())
return lignes, compte, qui
def contenu(dossier, f, debut=None, fin=None):
"""Ce que contient chaque source sur la fenêtre : ses colonnes, remplies ou vides, et les noms des métriques.
Des noms et des comptes, jamais de valeurs (metrics/ porte des identifiants : SIM_CCID, ip_*)."""
quoi = "sur la fenêtre" if debut or fin else "sur toute la période"
print(f"\nCe que contiennent les données, {quoi} (par colonne, les lignes qui ont une valeur ; « vide » : aucune) :")
autres = collections.defaultdict(list)
for p in f["autres"]:
autres[os.path.relpath(p, dossier).split(os.sep)[0]].append(p)
for titre, chemins in (("Export « advanced »", f["advanced"]), ("Pose de la caméra (camera/)", f["camera"]),
("Qualité d'image (quality/)", autres.pop("quality", []))):
if chemins:
n, compte, qui = remplies(chemins, debut, fin)
tous = set().union(*qui.values())
def porte(c): # nombre de capteurs qui portent la colonne, quand ce ne sont pas tous
return f" ({len(qui[c])} capteurs sur {len(tous)})" if tous and len(qui[c]) < len(tous) else ""
print(f" {titre} : {n} lignes ; " + ", ".join(f"{c} {k}{porte(c)}" if k else f"{c} vide" for c, k in compte.items()))
if chemins is f["advanced"]:
q = [c for c in QUALITE if compte.get(c)]
print(f" Qualité d'image de l'export (peak à snr) : " + (f"remplie ({', '.join(q)}) ; lue par qualite.py, "
"labeling/connaissances/metriques-de-qualite.md" if q else "vide"))
jours = collections.Counter() # métrique -> jours (un CSV par métrique et par jour) dans la fenêtre
for p in autres.pop("metrics", []):
m = METRIQUE_RE.match(os.path.basename(p))
if not m:
continue
jour = datetime(*map(int, m.group(2, 3, 4)), tzinfo=timezone.utc)
if (debut is None or jour.date() >= debut.date()) and (fin is None or jour.date() <= fin.date()):
nom = m.group(1)
jours[nom.split("_", 1)[1] if "_" in nom else nom] += 1
if jours:
print(f" Métriques système (metrics/, un CSV par métrique et par jour ; lues par metriques.py) : {len(jours)} : "
+ ", ".join(f"{k} ({n} j)" for k, n in sorted(jours.items())))
for titre, chemins in (("Images de la caméra", f["images"]),
("Images différentielles (images_diff/ ; aucun outil ne les lit)", glob.glob(os.path.join(dossier, "images_diff", "*")))):
heures = [h for h in map(heure_image, chemins) if h and filtrer([{"t": h}], debut, fin)]
if chemins:
print(f" {titre} : {len(heures)}")
if autres:
print(" Autres : " + ", ".join(f"{k} ({len(v)})" for k, v in sorted(autres.items())))
def images(chemins, debut=None, fin=None):
heures = sorted(h for h in map(heure_image, chemins) if h)
print(f"Images : {len(chemins)}" + (f", du {iso(heures[0])} au {iso(heures[-1])}" if heures else ""))
inconnues = [p for p in chemins if heure_image(p) is None]
if inconnues:
print(f" noms sans heure reconnue : {len(inconnues)}")
heures = [h for h in heures if filtrer([{"t": h}], debut, fin)]
if len(heures) < 2:
return
# Suites d'images à écart régulier (arrondi à 5 min, ce qui absorbe les quelques secondes de retard d'une prise) :
# une ligne par changement d'écart, sans rien perdre des heures couvertes.
suites = [] # [première, dernière, écart en min, nombre d'écarts]
for a, b in zip(heures, heures[1:]):
e = round((b - a).total_seconds() / 300) * 5
if suites and suites[-1][2] == e:
suites[-1][1], suites[-1][3] = b, suites[-1][3] + 1
else:
suites.append([a, b, e, 1])
quoi = "sur la fenêtre" if debut or fin else "entre la première et la dernière"
print(f" écart entre deux images {quoi}, par suite d'écarts égaux (à 5 min près) :")
for a, b, e, n in suites:
print(f" {iso(a)} → {iso(b)} : " + (f"{n + 1} images, toutes les {e} min" if n > 1 else f"un écart de {e} min"))
def mesures(par):
if not par:
print("\nAucune mesure : pas d'export « advanced » dans ce dossier.")
return
instants = sorted({m["t"] for ms in par.values() for m in ms})
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
print(f"\nPériode des mesures : {iso(instants[0])} → {iso(instants[-1])}, {len(instants)} instants")
print(f"Cadence (pas médian) : {cadence.total_seconds() / 60:.0f} min")
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(instants, instants[1:])]
trous = [x for x in trous if x[2] > 0]
print(f"Mesures manquantes (instants absents de la cadence) : {sum(n for *_, n in trous)}")
for a, b, n in trous:
print(f" entre {iso(a)} et {iso(b)} : {n}")
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
refs = [s for s in noms if est_reference(par[s])]
print(f"\nCapteurs : {len(par)} ({len(refs)} références, {len(par) - len(refs)} cibles)")
vides = [s for s in noms if not any(m["pattern_type"] for m in par[s])]
if vides:
print(f" pattern_type vide pour {len(vides)} capteurs : référence quand reproj_err ou inlier est rempli "
"(références seulement, labeling/connaissances/colonnes-des-deplacements.md)")
print(f"{'capteur':10} {'type':10} {'motif':11} {'seuil':>5} {'mesures':>7} {'rejetées':>8}")
for s in noms:
ms = par[s]
seuil = "/".join(f"{x:g}" for x in sorted({m['error_threshold'] for m in ms}))
print(f"{s:10} {'référence' if est_reference(ms) else 'cible':10} {ms[0]['pattern_type']:11} "
f"{seuil:>5} {len(ms):7} {sum(map(rejetee, ms)):8}")
def camera(dossier, par, debut=None, fin=None):
"""Poses de la caméra, et les instants de mesure sans pose (la caméra n'a pas été recalée)."""
poses = filtrer(charger_camera(dossier), debut, fin)
instants = sorted({m["t"] for ms in par.values() for m in filtrer(ms, debut, fin)})
quoi = "dans la fenêtre" if debut or fin else "sur toute la période"
if not poses:
print(f"\nPose de la caméra {quoi} : aucune")
return
avec = {p["t"].replace(second=0, microsecond=0) for p in poses}
print(f"\nPose de la caméra {quoi} : {len(poses)} recalages, {iso(poses[0]['t'])} → {iso(poses[-1]['t'])}")
suites = [] # [début, fin, nombre, rang] des instants de mesure consécutifs sans pose
for i, t in enumerate(instants):
if t.replace(second=0, microsecond=0) in avec:
continue
if suites and suites[-1][3] == i - 1:
suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i
else:
suites.append([t, t, 1, i])
print(f"Instants de mesure sans pose (pas de recalage) : {sum(x[2] for x in suites)} sur {len(instants)}")
if debut or fin:
for a, b, n, _ in suites:
print(f" {suite(a, b, n)}")
def fenetre(par, debut, fin):
"""Pas absents et rejets datés sur la fenêtre debut/fin."""
instants = sorted({m["t"] for ms in par.values() for m in ms})
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
series = {s: {m["t"]: m for m in filtrer(ms, debut, fin)} for s, ms in par.items()}
dans = sorted({t for d in series.values() for t in d})
print(f"\nFenêtre {iso(dans[0])} → {iso(dans[-1])} : {len(dans)} instants présents")
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
print(f"Pas absents pour tous les capteurs, entre deux instants présents (cadence de {cadence.total_seconds() / 60:.0f} min) :")
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(dans, dans[1:])]
trous = [x for x in trous if x[2] > 0]
for a, b, n in trous:
print(f" entre {iso(a)} et {iso(b)} : {n}")
if not trous:
print(" (aucun)")
print("Instants présents où des capteurs n'ont pas de mesure :")
partiels = [(t, [s for s in noms if t not in series[s]]) for t in dans]
for t, manque in partiels:
if manque:
print(f" {iso(t)} : {len(manque)} capteurs : {','.join(manque)}")
if not any(m for _, m in partiels):
print(" (aucun)")
print("Mesures rejetées dans la fenêtre, par capteur (début → fin de chaque suite de pas consécutifs, nombre) :")
for s in noms:
rej = [t for t in sorted(series[s]) if rejetee(series[s][t])]
suites = []
for t in rej:
if suites and t - suites[-1][1] <= cadence * 1.5:
suites[-1][1], suites[-1][2] = t, suites[-1][2] + 1
else:
suites.append([t, t, 1])
if rej:
print(f" {s} ({len(rej)}) : " + "; ".join(suite(a, b, n) for a, b, n in suites))
if not any(rejetee(m) for d in series.values() for m in d.values()):
print(" (aucune)")
refs = [s for s in noms if est_reference(par[s])]
# inlier dit quelles références la compensation retient ; certains exports ne le remplissent pas (et parfois
# reproj_err seulement) : on prend alors reproj_err rempli, et le titre le dit.
col = next((c for c in ("inlier", "reproj_err") if any(m[c] is not None for s in refs for m in series[s].values())), None)
if col is None:
print("Références retenues par la compensation : colonnes inlier et reproj_err absentes ou vides.")
return
retenue = (lambda m: m["inlier"] == 1) if col == "inlier" else (lambda m: m["reproj_err"] is not None)
def marque(s, t):
m = series[s].get(t)
return "absente" if m is None else "r" if rejetee(m) else "vide" if m[col] is None else f"{m[col]:g}"
hors = [(t, tuple((s, marque(s, t)) for s in refs if t not in series[s] or not retenue(series[s][t]))) for t in dans]
compte = collections.Counter(len(refs) - len(h) for _, h in hors)
quoi = "inlier = 1" if col == "inlier" else "inlier vide sur la fenêtre : reproj_err rempli à la place"
print(f"Références retenues par la compensation ({quoi}) sur {len(refs)}, nombre d'instants : "
+ ", ".join(f"{k} : {compte[k]}" for k in sorted(compte, reverse=True)))
print("Instants où des références ne sont pas retenues (suites de pas consécutifs avec les mêmes références hors ; "
f"r = rejetée, vide = {col} vide, sinon la valeur d'inlier) :")
suites = []
for i, (t, h) in enumerate(hors):
if h and suites and suites[-1][3] == h and suites[-1][4] == i - 1:
suites[-1][1], suites[-1][2], suites[-1][4] = t, suites[-1][2] + 1, i
elif h:
suites.append([t, t, 1, h, i])
for a, b, n, h, _ in suites:
print(f" {suite(a, b, n)} : {len(refs) - len(h)} retenues ; hors : "
+ ", ".join(f"{s} ({q})" for s, q in h))
if not suites:
print(" (aucun)")
def main(dossier, debut=None, fin=None, tout=False):
print(f"Dossier : {dossier}")
f = trouver(dossier)
fichiers(f, tout)
contenu(dossier, f, debut, fin)
images(f["images"], debut, fin)
par = charger(dossier)
mesures(par)
if par:
camera(dossier, par)
if par and (debut or fin):
fenetre(par, debut, fin)
camera(dossier, par, debut, fin)
if __name__ == "__main__":
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--fichiers", action="store_true", help="liste complète des fichiers (sinon : le premier et le dernier au-delà de 5)")
o = a.parse_args()
main(o.dossier, o.debut, o.fin, o.fichiers)
-333
View File
@@ -1,333 +0,0 @@
"""Ce qui revient d'un jour à l'autre : niveau de chaque nuit, et jours superposés par heure du jour, pour l'agent de diagnostic.
Usage : .venv/bin/python agent-tools/jours.py data/PS_DES_COUDRES/ [--colonnes corr_x,corr_y,error_value]
[--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes [--lissage N] [--fraction F]]
[--debut ...] [--fin ...] [--sortie DOSSIER]
Mesures acceptées seulement : une mesure rejetée (error_value au-dessus du seuil) n'entre nulle part. Une « nuit » :
les heures --nuit H1-H2 (UTC, H1 inclus, H2 exclu, à cheval sur minuit si H1 > H2), datée du jour où elle commence ;
la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit). Bruit propre du capteur : médiane des
écarts entre deux mesures consécutives sur la fenêtre. Pour chaque colonne de --colonnes :
1. Niveau de chaque nuit, par capteur : médiane, MAD et nombre de mesures ; puis, d'une nuit à la suivante, la
marche (différence des médianes, en unités et en bruits) et où elle se place : la suite des mesures de nuit des
deux nuits est coupée là où la somme des écarts absolus au niveau de la première nuit (avant) et de la seconde
(après) est la plus petite ; « entre A et B » : dernière mesure de nuit avant la coupure et première après (B en
début de nuit : la coupure tombe entre deux nuits, de jour).
2. Jours superposés : chaque mesure moins le niveau de la dernière nuit commencée à son instant (la précédente, ou
celle en cours ; sans elle, la nuit la plus proche). PNG « parheure-<colonne> » : un petit graphique par capteur,
en abscisse l'heure du jour (UTC), une courbe par jour, heures de nuit grisées, une échelle par capteur, cadrée du 1er au 99e centile élargi de moitié (le titre dit
combien de mesures sortent du cadre : un pic isolé n'écrase pas l'échelle ; sa valeur est dans les tables).
Table : par créneau de --pas de l'heure du jour, les capteurs dont l'écart dépasse --k bruits à ce créneau, du
même côté, au moins --jours jours différents, avec le nombre de ces jours sur le nombre de jours mesurés et la
médiane de ces écarts (signée, en unités et en bruits) ; un capteur au-dessus certains jours et au-dessous
d'autres est cité deux fois.
3. Avec --bornes : chaque jour face à la nuit qui le précède, pour la médiane des cibles de chaque colonne (avec
--capteurs : la médiane de ces capteurs, références comprises ; un seul capteur : le sien) et pour la pose de la
caméra (pan, tilt, rotation, scale, sigma0) si camera/ existe. Un « jour » : de la fin d'une nuit à la fin de la
suivante (24 h), daté du jour où il commence ; son niveau de référence est celui de la nuit qui vient de finir (sans
elle, la dernière nuit mesurée avant, ou au début du lot la première : nommée, « pas la précédente »). Écart de chaque mesure à ce niveau (médiane des cibles : à chaque
instant, médiane des écarts de chaque cible à son propre niveau de cette nuit) ; bruit : médiane des écarts entre
deux valeurs consécutives de cette suite. Par jour : nombre de mesures, première et dernière ; premier et dernier
instant où |écart| dépasse --k bruits, avec la mesure juste avant et juste après (au pas natif) ; le maximum et le
minimum signés et leur instant ; autour du plus grand des deux en valeur absolue, la suite de mesures consécutives
au-delà de --k bruits du même côté qui le contient, avec la mesure juste avant et juste après ; la nuit suivante
moins la nuit de référence. Un jour sans mesure le dit. Chaque ligne de jour commence par le nom court de la suite
(la colonne, ou pose_tilt…) : `| grep '^pose_tilt '` en garde une, `| grep ' 12/10 '` un jour. Avec --lissage N,
l'écart de chaque mesure est la médiane des N mesures du jour centrées sur elle (le bruit reste celui des mesures,
la figure trace aussi l'écart brut en gris) : un point isolé ne coupe plus la suite autour de l'extrême et ne fait
plus un premier ou un dernier dépassement. Avec --fraction F, le seuil de chaque jour est F fois le plus grand
|écart| de ce jour (au lieu de --k bruits ; il est imprimé sur la ligne du jour) : sur une suite très bruitée, ou
dont le bruit au pas natif est sans rapport avec l'ampleur du cycle. PNG
« bornes » : un panneau par suite, l'écart sur le lot, ±k bruits en pointillé, de chaque jour [premier, dernier]
grisé clair et la suite autour de l'extrême grisée foncé, le maximum et le minimum marqués ; cadré du 1er au 99e
centile élargi de moitié (le titre dit combien de mesures sortent du cadre).
Rend des valeurs, pas de verdict.
"""
import argparse
import math
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt # noqa: E402
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
from graphique import COLONNES, RACINE, borne # noqa: E402
from resume import ARRONDI, bruit_propre, duree # noqa: E402
def heures(texte):
"""'20-3' -> (20, 3)."""
try:
h1, h2 = (int(x) for x in texte.split("-"))
except ValueError:
raise argparse.ArgumentTypeError(f"heures invalides : {texte!r} (ex. 20-3)")
return h1, h2
def de_nuit(t, h1, h2):
return (h1 <= t.hour or t.hour < h2) if h1 > h2 else h1 <= t.hour < h2
def coupure(pts, la, lb):
"""Indice j (1..n-1) où sum|v-la| avant j + sum|v-lb| à partir de j est le plus petit."""
avant, apres = 0.0, sum(abs(v - lb) for _, v in pts)
meilleur = None
for j in range(1, len(pts)):
v = pts[j - 1][1]
avant += abs(v - la)
apres -= abs(v - lb)
if meilleur is None or avant + apres < meilleur[0]:
meilleur = (avant + apres, j)
return meilleur[1]
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--colonnes", default="corr_x,corr_y,error_value")
a.add_argument("--nuit", default="20-3", type=heures, help="heures de nuit H1-H2, UTC (défaut 20-3)")
a.add_argument("--k", type=float, default=5, help="écart au niveau de la nuit compté, en bruits propres du capteur")
a.add_argument("--jours", type=int, default=2, help="nombre de jours à partir duquel un capteur est cité à un créneau")
a.add_argument("--pas", default="15min", type=duree, help="largeur des créneaux de l'heure du jour (défaut 15min)")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--bornes", action="store_true", help="ajoute, jour par jour, les bornes de l'écart au niveau de la nuit précédente")
a.add_argument("--lissage", type=int, default=1, metavar="N", help="--bornes : écart lissé par la médiane de N mesures centrées (défaut 1 : aucun)")
a.add_argument("--fraction", type=float, metavar="F", help="--bornes : seuil de chaque jour = F fois son plus grand |écart| (au lieu de --k bruits)")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
o = a.parse_args()
par = charger(o.dossier)
if not par:
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
colonnes = o.colonnes.split(",")
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")):
absents = [x for x in demandes if x not in connus]
if absents:
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
series = {s: [m for m in filtrer(par[s], o.debut, o.fin) if not rejetee(m)] for s in noms}
if not any(series.values()):
sys.exit("Aucune mesure acceptée dans la fenêtre demandée.")
h1, h2 = o.nuit
pas = int(o.pas.total_seconds() // 60)
station = os.path.basename(os.path.normpath(o.dossier))
os.makedirs(o.sortie, exist_ok=True)
lignes = math.ceil(len(noms) / 5)
for col in colonnes:
print(f"\n== {col} : niveau de chaque nuit ({h1} h → {h2} h UTC), médiane ±MAD (mesures) ; marches d'une nuit à la suivante ==")
creneaux = {} # minute du jour -> {(capteur, au-dessus): {jour: écart}}
bruits = {}
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
for ax, s in zip(axes.flat, noms):
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
if len(ms) < 2:
print(f"{s:9}(moins de 2 valeurs acceptées)")
ax.axis("off")
continue
bruit = bruits[s] = bruit_propre([v for _, v in ms])
nuits = {}
for t, v in ms:
if de_nuit(t, h1, h2):
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append((t, v))
niv = {d: statistics.median(v for _, v in p) for d, p in nuits.items()}
cases = []
for d in sorted(nuits):
vs = [v for _, v in nuits[d]]
cases.append(f"{d:%d/%m} {niv[d]:+.6g} ±{statistics.median(abs(v - niv[d]) for v in vs):.2g} ({len(vs)})")
print(f"{s:9}bruit {bruit:.3g} | " + (" | ".join(cases) if cases else "aucune mesure de nuit"))
jours = sorted(nuits)
for da, db in zip(jours, jours[1:]):
pts = nuits[da] + nuits[db]
j = coupure(pts, niv[da], niv[db])
d = niv[db] - niv[da]
enb = f"{d / bruit:+.1f}" if bruit else "-"
print(f"{'':9}{da:%d/%m} → {db:%d/%m} : {d:+.4g} ({enb} bruits), entre {iso(pts[j - 1][0])} et {iso(pts[j][0])}")
def niveau_de(t):
d = (t - timedelta(hours=h1)).date()
if d in niv:
return niv[d]
return niv[min(niv, key=lambda x: abs((x - d).days))] if niv else statistics.median(v for _, v in ms)
par_jour = {}
for t, v in ms:
e = v - niveau_de(t)
par_jour.setdefault(t.date(), []).append((t.hour + t.minute / 60, e))
if bruit and abs(e) > o.k * bruit:
c = (t.hour * 60 + t.minute) // pas * pas
creneaux.setdefault(c, {}).setdefault((s, e > 0), {})[t.date()] = e
for i, (d, p) in enumerate(sorted(par_jour.items())):
ax.plot([x for x, _ in p], [e for _, e in p], "-", lw=0.8, color=f"C{i % 10}", label=f"{d:%d/%m}")
ax.axhline(0, color="0.3", ls=":", lw=0.8)
tous = sorted(e for p in par_jour.values() for _, e in p)
q1, q2 = tous[len(tous) // 100], tous[-1 - len(tous) // 100] # cadre du 1er au 99e centile : un pic isolé n'écrase pas l'échelle
marge = (q2 - q1) * 0.5 or 1
ax.set_ylim(q1 - marge, q2 + marge)
hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous)
for x0, x1 in ((h1, 24), (0, h2)) if h1 > h2 else ((h1, h2),):
ax.axvspan(x0, x1, color="0.9", lw=0)
ax.set_title(s + (" (réf.)" if est_reference(series[s]) else "") + f" bruit {bruit:.2g}"
+ (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
ax.set_xlim(0, 24)
ax.set_xticks(range(0, 25, 3))
ax.grid(alpha=0.3)
ax.tick_params(labelsize=7)
if ax is axes.flat[0]:
ax.legend(fontsize=6, ncol=2)
for ax in list(axes.flat)[len(noms):]:
ax.axis("off")
fig.suptitle(f"{station} : {col} moins le niveau de la dernière nuit ({h1} h → {h2} h, grisée), "
"une courbe par jour, en abscisse l'heure du jour (UTC) ; une échelle par capteur")
fig.tight_layout()
chemin = os.path.join(o.sortie, f"{station}_parheure-{col}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
fig.savefig(chemin, dpi=100, bbox_inches="tight")
plt.close(fig)
print(chemin)
nb_jours = {s: {} for s in noms} # capteur -> créneau -> jours mesurés
for s in noms:
for m in series[s]:
if m[col] is not None:
nb_jours[s].setdefault((m["t"].hour * 60 + m["t"].minute) // pas * pas, set()).add(m["t"].date())
print(f"\n{col} : par créneau de {pas} min de l'heure du jour, capteurs à plus de {o.k:g} bruits du niveau de la nuit "
f"au moins {o.jours} jours (jours / jours mesurés, médiane de ces écarts, en bruits)")
vide = True
for c in sorted(creneaux):
cites = []
for s, haut in ((s, h) for s in noms for h in (True, False)):
ec = creneaux[c].get((s, haut), {})
if len(ec) >= o.jours:
med = statistics.median(ec.values())
cites.append(f"{s} {len(ec)}/{len(nb_jours[s].get(c, ()))} {med:+.3g} ({med / bruits[s]:+.1f})")
if cites:
vide = False
print(f"{c // 60:02d}:{c % 60:02d} {len(cites):2} capteurs : " + ", ".join(cites))
if vide:
print("(aucun)")
if o.bornes:
bornes(o, noms, series, colonnes, station)
def niveaux_de_nuit(pts, h1, h2):
"""[(t, v)] -> {date de la nuit: médiane}."""
nuits = {}
for t, v in pts:
if de_nuit(t, h1, h2):
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append(v)
return {d: statistics.median(v) for d, v in nuits.items()}
def bornes(o, noms, series, colonnes, station):
"""Section 3 : par jour, l'écart au niveau de la nuit qui le précède, pour la médiane des cibles et la pose."""
h1, h2 = o.nuit
duree_nuit = timedelta(hours=(h2 - h1) % 24)
choisis = noms if o.capteurs else [s for s in noms if series[s] and not est_reference(series[s])] or noms
suites = [(f"{col} médiane de {len(choisis)} capteur(s)" if len(choisis) > 1 else f"{col} {choisis[0]}", col,
{s: [(m["t"], m[col]) for m in series[s] if m[col] is not None] for s in choisis}) for col in colonnes]
poses = filtrer(charger_camera(o.dossier), o.debut, o.fin)
suites += [(f"pose {c}", f"pose_{c}", {c: [(p["t"], p[c]) for p in poses if p[c] is not None]}) for c in POSE
if any(p[c] is not None for p in poses)]
tous = [t for _, _, d in suites for p in d.values() for t, _ in p]
t0, t1 = min(tous), max(tous)
nuit_de = lambda t: (t - duree_nuit - timedelta(hours=h1)).date() # nuit qui finit avant t (le jour de t commence à sa fin)
jours = [nuit_de(t0) + timedelta(days=i) for i in range((nuit_de(t1) - nuit_de(t0)).days + 1)]
hm = lambda t: f"{t:%d/%m %H:%M}"
seuil_txt = f"seuil {o.fraction:g} fois le plus grand |écart| du jour" if o.fraction else f"seuil {o.k:g} bruits"
print(f"\n== Bornes de chaque jour : écart au niveau de la nuit qui le précède ({h1} h → {h2} h UTC), {seuil_txt}"
+ (f", écart lissé sur {o.lissage} mesures" if o.lissage > 1 else "") + " ==")
print("jour : de la fin d'une nuit à la fin de la suivante, daté de son début ; « avant », « après » : mesure juste avant le premier "
"dépassement, juste après le dernier ; nuit suivante : son niveau moins celui de la nuit de référence")
fig, axes = plt.subplots(len(suites), 1, sharex=True, figsize=(18, 2.2 * len(suites)), squeeze=False)
for ax, (nom, court, par_capteur) in zip(axes.flat, suites):
niv = {s: niveaux_de_nuit(p, h1, h2) for s, p in par_capteur.items()}
nuits = sorted({d for n in niv.values() for d in n})
ecarts = [] # (jour, nuit de réf., [(t, écart)], écart de la nuit suivante)
for d in jours:
debut = datetime.combine(d, datetime.min.time(), tzinfo=timezone.utc) + timedelta(hours=h1) + duree_nuit
fin = debut + timedelta(days=1)
ref = max((n for n in nuits if n <= d), default=None) or (min(nuits) if nuits else None)
par_t = {}
for s, p in par_capteur.items():
if ref in niv[s]:
for t, v in p:
if debut <= t < fin:
par_t.setdefault(t, []).append(v - niv[s][ref])
suivante = [niv[s][d + timedelta(days=1)] - niv[s][ref] for s in niv if ref in niv[s] and d + timedelta(days=1) in niv[s]]
ecarts.append((debut.date(), d, ref, [(t, statistics.median(e)) for t, e in sorted(par_t.items())],
statistics.median(suivante) if suivante else None))
diffs = [abs(b[1] - a_[1]) for *_, p, _ in ecarts for a_, b in zip(p, p[1:])]
bruit = statistics.median(diffs) if diffs else 0
bruit = bruit if bruit >= ARRONDI else 0
print(f"\n{nom} : bruit {bruit:.3g}")
enb = lambda e: f"{e:+.4g} ({e / bruit:+.1f})" if bruit else f"{e:+.4g}"
h = o.lissage // 2
for jour, d, ref, brut, suiv in ecarts:
if not brut:
print(f"{court} {jour:%d/%m} aucune mesure" + ("" if nuits else " de nuit"))
continue
p = [(t, statistics.median(e for _, e in brut[max(0, i - h):i + h + 1])) for i, (t, _) in enumerate(brut)] if h else brut
seuil = o.fraction * max(abs(e) for _, e in p) if o.fraction else o.k * bruit
ligne = (f"{court} {jour:%d/%m} nuit {ref:%d/%m}" + (" (pas la précédente)" if ref != d else "") + f" | {len(p)} mesures {hm(p[0][0])} → {hm(p[-1][0])} | "
+ (f"seuil {seuil:.4g} | " if o.fraction else ""))
hors = [i for i, (_, e) in enumerate(p) if seuil and abs(e) > seuil]
if hors:
i, j = hors[0], hors[-1]
ligne += (f"> {'seuil' if o.fraction else f'{o.k:g} bruits'} : {len(hors)} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
ax.axvspan(p[i][0], p[j][0], color="0.85", lw=0)
else:
ligne += f"jamais > {'seuil' if o.fraction else f'{o.k:g} bruits'}"
haut, bas = max(p, key=lambda x: x[1]), min(p, key=lambda x: x[1])
ligne += f" | max {enb(haut[1])} à {hm(haut[0])}, min {enb(bas[1])} à {hm(bas[0])}"
x = max(range(len(p)), key=lambda i: abs(p[i][1]))
signe = 1 if p[x][1] > 0 else -1
if seuil and signe * p[x][1] > seuil:
i = j = x
while i > 0 and signe * p[i - 1][1] > seuil:
i -= 1
while j + 1 < len(p) and signe * p[j + 1][1] > seuil:
j += 1
ligne += (f" | autour du {'max' if signe > 0 else 'min'} : {j - i + 1} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
ax.axvspan(p[i][0], p[j][0], color="0.7", lw=0)
ligne += f" | nuit suivante {enb(suiv)}" if suiv is not None else " | nuit suivante non mesurée"
print(ligne)
if h:
ax.plot([t for t, _ in brut], [e for _, e in brut], "-", lw=0.5, color="0.6")
ax.plot([t for t, _ in p], [e for _, e in p], "-", lw=0.8, color="C0")
ax.plot([haut[0], bas[0]], [haut[1], bas[1]], "o", ms=3, color="C3")
if bruit and not o.fraction:
for y in (o.k * bruit, -o.k * bruit):
ax.axhline(y, color="0.4", ls=":", lw=0.8)
ax.axhline(0, color="0.3", lw=0.5)
tous_e = sorted(e for *_, p, _ in ecarts for _, e in p)
hors_cadre = 0
if tous_e: # cadre du 1er au 99e centile élargi de moitié, comme parheure : un pic isolé n'écrase pas l'échelle
q1, q2 = tous_e[len(tous_e) // 100], tous_e[-1 - len(tous_e) // 100]
marge = (q2 - q1) * 0.5 or 1
ax.set_ylim(q1 - marge, q2 + marge)
hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous_e)
ax.set_title(f"{nom} bruit {bruit:.2g}" + (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
ax.grid(alpha=0.3)
ax.tick_params(labelsize=7)
fig.suptitle(f"{station} : écart au niveau de la nuit qui précède chaque jour ({h1} h → {h2} h) ; "
f"grisé clair : du premier au dernier dépassement {'du seuil (' + seuil_txt + ')' if o.fraction else f'de {o.k:g} bruits'}, foncé : la suite autour de l'extrême ; points : max et min du jour"
+ (f" ; écart lissé sur {o.lissage} mesures (bleu), brut (gris)" if o.lissage > 1 else ""))
fig.tight_layout()
chemin = os.path.join(o.sortie, f"{station}_bornes_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
fig.savefig(chemin, dpi=100, bbox_inches="tight")
plt.close(fig)
print(chemin)
if __name__ == "__main__":
main()
-264
View File
@@ -1,264 +0,0 @@
"""Métriques système de la station (metrics/ : températures, tension, batterie, lien…), en table et en figure,
face à la médiane des cibles de corr_x, corr_y et à la pose de la caméra.
Usage : .venv/bin/python agent-tools/metriques.py data/PS_DES_COUDRES/
[--noms sensor_A0_deg_c,BusVoltage] [--pas 1h] [--stat median|min|max] [--contre temperature] [--lissage 24h]
[--metriques-seules] [--debut ...] [--fin ...] [--sortie DOSSIER]
Colonnes : `temperature` (médiane des composants sensor_*_deg_c à chaque heure, comme la lisent les détecteurs,
donnees.charger_temperature), puis chaque métrique de --noms (défaut : les *_deg_c et BusVoltage présents), puis,
sauf --metriques-seules, cib_corr_x, cib_corr_y (à chaque mesure, médiane sur les cibles de corr moins le niveau
propre de la cible, sa médiane sur la fenêtre ; mesures acceptées seulement) et la pose brute de la caméra (cam_pan,
cam_tilt, cam_rotation, cam_scale, cam_sigma0). Une case vide d'un CSV de metrics/ est sautée, pas lue comme zéro.
Une métrique texte (BatteryState, link, last_sync…) est rendue telle quelle (la dernière du pas).
Jamais d'identifiant : SIM_CCID et ip* ne sont ni lus ni listés.
Imprime : les métriques disponibles ; la table, une ligne par pas de --pas (début du pas, UTC ; --stat des valeurs du
pas ; « - » : aucune valeur), les pas où aucune métrique n'a de valeur n'y sont pas ; par colonne, le nombre de pas
remplis, le minimum et le maximum avec leur instant ; la corrélation r et la pente (moindres carrés, sur les pas où
les deux ont une valeur) de chaque colonne numérique sur --contre (défaut temperature ; avec --lissage D, sur sa
moyenne glissante centrée sur D, colonne <contre>_lisse) ; les suites datées de pas sans aucune métrique.
Un PNG, chemin imprimé : températures sur un panneau, chaque autre métrique numérique sur le sien, puis cib_corr_x,
cib_corr_y et la pose, aux instants natifs (trait coupé sur un trou). Rend des valeurs, pas de verdict.
"""
import argparse
import csv
import glob
import os
import statistics
import sys
from datetime import date, timedelta
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates # noqa: E402
import matplotlib.pyplot as plt # noqa: E402
from donnees import POSE, charger, charger_camera, charger_temperature, est_reference, filtrer, instant, iso # noqa: E402
from graphique import RACINE, borne # noqa: E402
from inventaire import METRIQUE_RE # noqa: E402
from resume import STATS, duree # noqa: E402
def identifiant(nom):
"""Métrique qui porte un identifiant (carte SIM, adresses IP) : jamais lue."""
return nom == "SIM_CCID" or nom.startswith("ip")
def valeur(texte):
v = texte.strip().strip("[]").strip("'\"")
try:
return float(v)
except ValueError:
return v or None
def lire_metriques(dossier, debut, fin):
"""metrics/ -> {nom: [{'t', 'v'}]} triées, sur la fenêtre ; v float ou texte ; case vide sautée ; nom sans valeur : []."""
prefixe = os.path.basename(os.path.normpath(dossier)) + "_"
par = {}
for p in glob.glob(os.path.join(dossier, "metrics", "*.csv")):
m = METRIQUE_RE.match(os.path.basename(p))
if not m:
continue
nom = m.group(1)
nom = nom[len(prefixe):] if nom.startswith(prefixe) else nom.split("_", 1)[-1]
if identifiant(nom):
continue
jour = date(*map(int, m.group(2, 3, 4)))
serie = par.setdefault(nom, {})
if (debut and jour < debut.date() - timedelta(days=1)) or (fin and jour > fin.date()):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
if (v := valeur(r.get("metric") or "")) is not None:
serie[instant(r["time_utc"])] = v
return {n: filtrer([{"t": t, "v": s[t]} for t in sorted(s)], debut, fin) for n, s in par.items()}
def cibles(par, col, debut, fin):
"""À chaque mesure, médiane sur les cibles de col moins le niveau propre de la cible (médiane sur la fenêtre)."""
ecarts = {}
for s, ms in par.items():
if est_reference(ms):
continue
ms = [m for m in filtrer(ms, debut, fin) if m[col] is not None]
if ms:
niveau = statistics.median(m[col] for m in ms)
for m in ms:
ecarts.setdefault(m["t"], []).append(m[col] - niveau)
return [{"t": t, "v": statistics.median(v)} for t, v in sorted(ecarts.items())]
def lisser(serie, largeur):
"""Moyenne glissante centrée sur largeur (valeurs numériques)."""
pts = [p for p in serie if isinstance(p["v"], float)]
# ponytail: O(n²), assez pour des métriques horaires sur quelques semaines
return [{"t": p["t"], "v": statistics.fmean(q["v"] for q in pts if abs(q["t"] - p["t"]) <= largeur / 2)} for p in pts]
def fmt(v):
return "-" if v is None else f"{v:.6g}" if isinstance(v, float) else str(v)
def suites(pas_vides, pas):
"""[t] triés -> [(début, fin, n)] de pas consécutifs."""
out = []
for t in pas_vides:
if out and t - out[-1][1] == pas:
out[-1] = (out[-1][0], t, out[-1][2] + 1)
else:
out.append((t, t, 1))
return out
def coupe(serie):
"""Instants et valeurs numériques, NaN inséré sur un écart de plus de 1,5 fois le pas habituel (le trait se coupe)."""
pts = [(p["t"], p["v"]) for p in serie if isinstance(p["v"], float)]
if len(pts) < 3:
return [t for t, _ in pts], [v for _, v in pts]
pas = statistics.median(b[0] - a[0] for a, b in zip(pts, pts[1:]))
ts, vs = [pts[0][0]], [pts[0][1]]
for (a, _), (b, v) in zip(pts, pts[1:]):
if b - a > 1.5 * pas:
ts.append(a + (b - a) / 2)
vs.append(float("nan"))
ts.append(b)
vs.append(v)
return ts, vs
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--noms", help="métriques, séparées par des virgules (défaut : les *_deg_c et BusVoltage présents)")
a.add_argument("--pas", default="1h")
a.add_argument("--stat", default="median", choices=STATS)
a.add_argument("--contre", default="temperature", help="colonne sur laquelle r et la pente sont calculés")
a.add_argument("--lissage", type=duree, help="moyenne glissante centrée de --contre, ex. 24h")
a.add_argument("--metriques-seules", action="store_true", help="sans cib_corr_x, cib_corr_y ni la pose")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
o = a.parse_args()
pas = duree(o.pas)
met = lire_metriques(o.dossier, o.debut, o.fin)
if not met:
print(f"Pas de metrics/ dans {o.dossier}.")
else:
print("Métriques disponibles (valeurs sur la fenêtre ; identifiants SIM_CCID, ip* exclus) : "
+ ", ".join(f"{n} ({len(s)})" if s else f"{n} (vide)" for n, s in sorted(met.items())))
if o.noms:
noms = o.noms.split(",")
if interdits := [n for n in noms if identifiant(n)]:
sys.exit(f"Identifiants, jamais lus : {', '.join(interdits)}.")
if absents := [n for n in noms if n not in met]:
sys.exit(f"Métriques inconnues : {', '.join(absents)}. Connues : {', '.join(sorted(met))}.")
else:
noms = sorted(n for n in met if n.endswith("_deg_c")) + [n for n in ("BusVoltage",) if n in met]
series = {"temperature": filtrer([{"t": t, "v": v} for t, v in charger_temperature(o.dossier)], o.debut, o.fin)}
series.update({n: met[n] for n in noms})
if o.lissage:
if o.contre not in series:
sys.exit(f"--contre {o.contre} : pas une colonne ({', '.join(series)}).")
series[o.contre + "_lisse"] = lisser(series[o.contre], o.lissage)
metriques = list(series)
if not o.metriques_seules:
par = charger(o.dossier)
for c in ("corr_x", "corr_y"):
series["cib_" + c] = cibles(par, c, o.debut, o.fin)
poses = filtrer(charger_camera(o.dossier), o.debut, o.fin)
for c in POSE:
series["cam_" + c] = [{"t": p["t"], "v": p[c]} for p in poses if p[c] is not None]
reference = o.contre + "_lisse" if o.lissage else o.contre
if reference not in series:
sys.exit(f"--contre {o.contre} : pas une colonne ({', '.join(series)}).")
tous = [p["t"] for s in series.values() for p in s]
if not tous:
sys.exit("Aucune valeur dans la fenêtre demandée.")
t0 = (o.debut or min(tous)).replace(minute=0, second=0, microsecond=0)
t1 = o.fin or max(tous)
cases = {} # colonne -> début du pas -> valeurs
for c, s in series.items():
for p in s:
cases.setdefault(c, {}).setdefault(t0 + ((p["t"] - t0) // pas) * pas, []).append(p["v"])
stat = STATS[o.stat]
table = {c: {k: (stat(v) if all(isinstance(x, float) for x in v) else v[-1]) for k, v in d.items()}
for c, d in cases.items()}
grille = [t0 + i * pas for i in range(int((t1 - t0) / pas) + 1)]
colonnes = list(series)
print(f"\n{o.stat} par pas de {o.pas} (début du pas, UTC) ; « - » : aucune valeur ; cib_ : écart au niveau propre des cibles")
print("\t".join(["heure"] + colonnes))
for k in grille:
ligne = [table.get(c, {}).get(k) for c in colonnes]
if any(v is not None for v in ligne):
print("\t".join([iso(k)] + [fmt(v) for v in ligne]))
print(f"\nPar colonne ({len(grille)} pas) :")
for c in colonnes:
d = table.get(c, {})
nums = [(v, k) for k, v in d.items() if isinstance(v, float)]
if not d:
print(f" {c} : vide")
elif nums:
(vmin, kmin), (vmax, kmax) = min(nums), max(nums)
print(f" {c} : {len(d)} pas ; min {fmt(vmin)} ({iso(kmin)}) ; max {fmt(vmax)} ({iso(kmax)})")
else:
ks = sorted(d)
print(f" {c} : {len(d)} pas, texte ; {len(set(d.values()))} valeurs distinctes ; "
f"première {d[ks[0]]} ({iso(ks[0])}) ; dernière {d[ks[-1]]} ({iso(ks[-1])})")
ref = table.get(reference, {})
print(f"\nCorrélation r et pente sur {reference} (par pas où les deux ont une valeur) :")
if not any(isinstance(v, float) for v in ref.values()):
print(f" {reference} vide : aucune")
for c in colonnes:
if c == reference or not ref or not any(isinstance(v, float) for v in table.get(c, {}).values()):
continue
paires = [(ref[k], v) for k, v in table.get(c, {}).items()
if isinstance(v, float) and isinstance(ref.get(k), float)]
try:
r = statistics.correlation(*zip(*paires))
pente = statistics.linear_regression(*zip(*paires)).slope
print(f" {c} : r = {r:+.2f} ; pente = {pente:.4g} par unité de {reference} ; n = {len(paires)}")
except (statistics.StatisticsError, TypeError, ValueError):
print(f" {c} : - (n = {len(paires)})")
vides = [k for k in grille if all(k not in table.get(c, {}) for c in metriques)]
print(f"\nPas sans aucune métrique ({', '.join(metriques)}) : {len(vides)} sur {len(grille)}")
for d, f, n in suites(vides, pas):
print(f" {iso(d)} → {iso(f)} ({n} pas)")
panneaux = {} # titre -> colonnes
for c in colonnes:
if any(isinstance(p["v"], float) for p in series[c]):
cle = "°C" if c.startswith("temperature") or "_deg_c" in c else c
panneaux.setdefault(cle, []).append(c)
if not panneaux:
print("\nRien à tracer.")
return
fig, axes = plt.subplots(len(panneaux), 1, sharex=True, figsize=(14, 2.4 * len(panneaux)), squeeze=False,
layout="constrained")
for ax, (titre, cols) in zip(axes[:, 0], panneaux.items()):
for c in cols:
noir = c in ("temperature", reference)
ax.plot(*coupe(series[c]), ".-", ms=2, lw=1.4 if noir else 0.7, label=c, zorder=3 if noir else 2,
color="k" if c == "temperature" else None)
if len(cols) > 1:
ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
ax.set_ylabel(titre if titre == "°C" else titre.replace("_", "_\n", 1), fontsize=8)
ax.grid(alpha=0.3)
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
station = os.path.basename(os.path.normpath(o.dossier))
fig.suptitle(f"{station} : métriques, cibles et pose (heures UTC)")
os.makedirs(o.sortie, exist_ok=True)
sortie = os.path.join(o.sortie, f"{station}_metriques_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
fig.savefig(sortie, dpi=100, bbox_inches="tight")
print(f"\n{sortie}")
if __name__ == "__main__":
main()
-156
View File
@@ -1,156 +0,0 @@
"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic.
Usage : python3 agent-tools/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y]
[--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N]
[--capteurs A,B] [--debut ...] [--fin ...]
Pour chaque colonne, chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane des
valeurs non vides ; avec --hors T1/T2, celle du reste de la fenêtre, hors du moment lu : utile quand un épisode
long fausse la médiane) et à son bruit propre (médiane des écarts entre deux mesures consécutives non vides, hors --hors).
1. Un tableau par colonne : niveau, bruit, et le plus grand saut d'une mesure à la suivante (valeur, en bruits,
les deux instants).
2. Les plages où la colonne s'écarte de son niveau de plus de --k bruits : début et fin (première et dernière
mesure hors niveau), nombre de mesures hors niveau, valeur extrême (écart signé au niveau, en unités et en
bruits) et son instant. Deux plages du même sens séparées de moins de --fusion (défaut 1h) n'en font qu'une
(un écart vers le bas puis vers le haut font deux plages) ; les mesures rejetées (colonne vide) ne coupent pas
une plage. Colonne « rejetées » : combien des mesures de la plage sont rejetées par la station (error_value
au-dessus du seuil), et « extrême rejetée » si l'extrême l'est ; un saut dont un bout est rejeté le dit.
corr_x, corr_y d'une mesure rejetée sont vides, références comprises (donnees.charger). Une plage qui touche le bord de la fenêtre est datée au
bord (le niveau est celui de la fenêtre : un palier durable peut faire de l'autre moitié la « plage »).
Avec --min-mesures N, seules les plages d'au moins N mesures hors niveau sont imprimées (leur nombre total aussi).
Avec --glissant N (un entier : N mesures non vides de part et d'autre) ou --glissant DUREE (6h, 1d : les mesures
à moins de DUREE avant et après), le niveau de chaque mesure est la médiane de ses voisines, sans elle (niveau
local) : une dérive longue ou un palier suivent le niveau, seuls restent les écarts plus brefs que la fenêtre.
La colonne « niveau » du tableau 1 reste la médiane de la fenêtre ; le bruit ne change pas.
3. Avec --instants N : les instants où au moins N capteurs sont hors niveau (sur l'une des colonnes), avec, pour
chacun, les capteurs et l'écart en bruits (cx corr_x, cy corr_y, ev error_value, sinon le nom de la colonne),
les capteurs rejetés à cet instant (parmi --capteurs : en retirer les capteurs toujours rejetés allège la liste),
et chaque référence de la station, --capteurs ou non : error_value (« r » si rejetée) / inlier (« - » vide).
Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict.
"""
import argparse
import bisect
import statistics
import sys
from donnees import charger, est_reference, filtrer, instant, iso, rejetee
from resume import COLONNES, bruit_propre, duree
ABREGE = {"corr_x": "cx", "corr_y": "cy", "error_value": "ev"}
def locaux(ms, g):
"""Niveau local de chaque mesure (t, v) : médiane des voisines non vides, sans elle ; g entier (mesures de part et
d'autre) ou timedelta (mesures à moins de g) ; None sans voisine."""
ts, vs = [t for t, _ in ms], [v for _, v in ms]
out = []
for i, t in enumerate(ts):
lo, hi = (max(0, i - g), i + g + 1) if isinstance(g, int) else (bisect.bisect_left(ts, t - g), bisect.bisect_right(ts, t + g))
w = vs[lo:i] + vs[i + 1:hi]
out.append(statistics.median(w) if w else None)
return out
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--colonnes", default="error_value,corr_x,corr_y")
a.add_argument("--k", type=float, default=5, help="écart au niveau compté, en bruits propres du capteur")
a.add_argument("--fusion", default="1h", type=duree, help="deux plages séparées de moins que cela n'en font qu'une")
a.add_argument("--min-mesures", type=int, default=1, help="n'imprime que les plages d'au moins N mesures hors niveau")
a.add_argument("--hors", help="T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)")
a.add_argument("--glissant", type=lambda x: int(x) if x.isdigit() else duree(x),
help="N (mesures de part et d'autre) ou durée (6h, 1d) : niveau local, médiane des voisines sans la mesure")
a.add_argument("--instants", type=int, help="N : instants où au moins N capteurs sont hors niveau, avec rejets et références")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
o = a.parse_args()
par = charger(o.dossier)
if not par:
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
colonnes = o.colonnes.split(",")
hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None
if hors and len(hors) != 2:
sys.exit("--hors attend T1/T2.")
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")):
absents = [x for x in demandes if x not in connus]
if absents:
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
series = {s: filtrer(par[s], o.debut, o.fin) for s in noms}
if not any(series.values()):
sys.exit("Aucune mesure dans la fenêtre demandée.")
glis = (f"{o.glissant} mesures" if isinstance(o.glissant, int) else f"{int(o.glissant.total_seconds() // 60)} min") if o.glissant is not None else ""
par_instant = {} # iso(t) -> ["capteur.col+écart"] (--instants)
for col in colonnes:
print(f"\n== {col} : niveau, bruit, plus grand saut d'une mesure à la suivante ==")
print(f"{'capteur':9}{'n':>5}{'niveau':>10}{'bruit':>10}{'saut':>10}{'(bruits)':>9} entre")
plages = []
for s in noms:
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
rej = {m["t"] for m in series[s] if rejetee(m)}
if len(ms) < 2:
print(f"{s:9}{len(ms):5} (moins de 2 valeurs)")
continue
ref = [x for x in ms if not hors or not hors[0] <= x[0] <= hors[1]]
if len(ref) < 2:
print(f"{s:9}{len(ms):5} (moins de 2 valeurs hors --hors)")
continue
niv = statistics.median(v for _, v in ref)
sauts = [(b[1] - a_[1], a_[0], b[0]) for a_, b in zip(ms, ms[1:])]
bruit = bruit_propre([v for _, v in ref])
d, t1, t2 = max(sauts, key=lambda x: abs(x[0]))
bru = f"{d / bruit:9.1f}" if bruit else f"{'-':>9}"
marque = [iso(x) for x in (t1, t2) if x in rej]
print(f"{s:9}{len(ms):5}{niv:10.4g}{bruit:10.3g}{d:+10.4g}{bru} {iso(t1)} et {iso(t2)}"
+ (f" (rejetée : {', '.join(marque)})" if marque else ""))
if not bruit:
continue
lv = locaux(ms, o.glissant) if o.glissant is not None else [niv] * len(ms)
groupe = [] # (t, écart au niveau)
for (t, v), n in zip(ms + [(None, 0)], lv + [None]):
if t is not None and n is not None and abs(v - n) > o.k * bruit:
if groupe and (t - groupe[-1][0] > o.fusion or (v > n) != (groupe[-1][1] > 0)): # même sens seul
plages.append((s, groupe, bruit, rej))
groupe = []
groupe.append((t, v - n))
par_instant.setdefault(iso(t), {}).setdefault(s, []).append(f"{ABREGE.get(col, col)}{(v - n) / bruit:+.0f}")
elif t is None and groupe:
plages.append((s, groupe, bruit, rej))
toutes = len(plages)
plages = [p for p in plages if len(p[1]) >= o.min_mesures]
print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' glissant ±' + glis + ' (médiane des voisines)' if glis else ''}{' (niveau hors ' + o.hors + ')' if hors and not glis else ''}{' (bruit hors ' + o.hors + ')' if hors and glis else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)"
+ (f" ; {len(plages)} d'au moins {o.min_mesures} mesures sur {toutes}" if o.min_mesures > 1 else ""))
print(f"{'capteur':9}{'début':<18}{'fin':<18}{'mesures':>8}{'extrême':>10}{'(bruits)':>9} {'à':<17}{'rejetées':>9}")
for s, g, bruit, rej in plages:
t, d = max(g, key=lambda x: abs(x[1]))
print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{d:+10.4g}{d / bruit:9.1f} {iso(t):<17}"
f"{sum(x[0] in rej for x in g):9}{' extrême rejetée' if t in rej else ''}")
if not plages:
print("(aucune)")
if o.instants is not None:
refs = sorted(s for s in par if est_reference(par[s]))
rej_t, ref_t = {}, {s: {} for s in refs}
for s in set(noms) | set(refs):
for m in filtrer(par[s], o.debut, o.fin):
if rejetee(m) and s in noms:
rej_t.setdefault(iso(m["t"]), []).append(s)
if s in ref_t:
ref_t[s][iso(m["t"])] = m
f = lambda v, fmt: "-" if v is None else format(v, fmt)
lignes = [(t, c) for t, c in sorted(par_instant.items()) if len(c) >= o.instants]
print(f"\nInstants où au moins {o.instants} capteurs sont à plus de {o.k:g} bruits du niveau{' glissant ±' + glis if glis else ''} "
f"({', '.join(colonnes)}) : {len(lignes)} sur {len(par_instant)} instants avec au moins un capteur hors niveau")
print("instant n capteurs hors niveau (écart en bruits) | rejetés | références : error_value (r rejetée) / inlier")
for t, c in lignes:
r = " ".join(f"{s} {f(ref_t[s][t]['error_value'], '.3g')}{'r' if rejetee(ref_t[s][t]) else ''}/{f(ref_t[s][t]['inlier'], 'g')}"
for s in refs if t in ref_t[s])
print(f"{t} {len(c):3} {' '.join(s + '.' + ','.join(v) for s, v in c.items())} | {','.join(rej_t.get(t, [])) or '-'} | {r or '-'}")
if __name__ == "__main__":
main()
-418
View File
@@ -1,418 +0,0 @@
"""Les six métriques de qualité d'image (peak, flux, sharpness, fwhm, dominance, snr) par capteur, face à sa référence calme.
Usage : python3 agent-tools/qualite.py <dossier> [--debut T] [--fin T] [--capteurs A,B] [--calme T1/T2,T3/T4]
[--commun] [--table METRIQUE] [--pas 15min] [--seuil 0.5]
python3 agent-tools/qualite.py <dossier> --etiquettes labeling/auto/X.jsonl [--calme ...] [--debut T] [--fin T]
[--numeros 3,7] [--seuil 0.5] [--marge 60] [--bords] | [--hors [--min 1] [--sauf "Thermal displacement"]]
.venv/bin/python agent-tools/qualite.py <dossier> --figure [--calme ...] [--debut T] [--fin T]
[--metriques flux,snr,dominance] [--etiquettes F] [--zone T1/T2 ...] [--sortie D]
python3 agent-tools/qualite.py --essai (contrôle du calcul du rapport)
Définitions : labeling/connaissances/metriques-de-qualite.md. Colonnes remplies sur les caméras récentes seulement ; sur un dossier où
elles sont vides, l'outil le dit et s'arrête.
Référence d'un capteur : la médiane de chaque métrique sur ses mesures des fenêtres --calme, à la même heure UTC du jour
(24 créneaux ; un créneau sans mesure calme prend la médiane de toutes les heures calmes). Sans --calme : tout le dossier.
Chaque mesure devient un rapport valeur / référence : 1 = comme la référence ; < 1 plus bas ; > 1 plus haut. Pour fwhm et
dominance, c'est la hausse qui dit une image dégradée (tache plus large, second pic plus fort). Mesures rejetées comprises
(la qualité de leur image reste mesurée).
Sans --etiquettes ni --figure :
1. le peak maximal du dossier, puis le résumé par capteur : mesures rejetées, « pk/max » (peak médian du capteur sur la
fenêtre divisé par ce maximum : une tache au plafond de l'image a un peak constant), et pour chaque métrique le rapport médian sur la fenêtre et l'extrême (min pour peak, flux, sharpness, snr ; max pour
fwhm, dominance) avec son instant ; puis les lignes « cibles » et « références » : la médiane des rapports médians ;
2. --commun : par pas de --pas, la médiane des rapports des cibles et celle des références, pour chaque métrique ;
3. --table M : par pas, le rapport de M de chaque capteur (« * » : une mesure du pas rejetée), « méd » (médiane sur les
capteurs) et le nombre de capteurs sous --seuil (au-dessus de 1/--seuil pour fwhm et dominance).
--etiquettes F (un JSON par ligne, debut, fin, categorie), sans --figure : par étiquette (numérotée dans l'ordre du
fichier ; --debut/--fin gardent celles qui y commencent), le rapport médian des cibles et des références sur l'heure
d'avant, la plage et l'heure d'après (--marge minutes) : « cib 0.95|0.40|0.97 » ; puis les capteurs « touchés » sur la
plage (flux ou snr sous --seuil, ou dominance au-dessus de 1/--seuil), avec leur pire rapport de flux, du plus bas au plus
haut (r = référence). --bords : par instant de la plage élargie de --marge, le nombre de capteurs touchés et la médiane
des cibles de flux, snr, dominance (« < » : dans la plage). --hors : à la place, les suites d'instants de --debut à --fin
qu'aucune étiquette ne couvre (hors familles --sauf), où au moins --min capteurs sont touchés (instants à moins de 15 min
groupés), avec les capteurs touchés et leur pire flux.
--figure (matplotlib) : PNG « qualite-commun » : un panneau par métrique, échelle logarithmique, médiane des cibles (noir),
des références (rouge) et bande du 10e au 90e centile des cibles ; PNG « qualite-<métrique> » par --metriques : un petit
graphique par capteur, références en rouge. --etiquettes grise chaque étiquette d'une couleur par famille ; --zone grise
des plages. Trait coupé sur un trou de plus de 30 min. Imprime le chemin de chaque PNG.
Rend des valeurs, pas de verdict. Lancé depuis la racine du dépôt.
"""
import argparse
import bisect
import json
import os
import statistics
import sys
from datetime import timedelta
import donnees
from resume import QUALITE as METRIQUES, duree
HAUT_MAUVAIS = ("fwhm", "dominance") # pour ces deux-là, c'est la hausse qui dit une image dégradée
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
COULEURS = {"Visibility": "tab:blue", "Obstruction": "tab:orange", "Thermal displacement": "tab:red",
"Displacement": "tab:purple", "Target issue": "tab:brown", "No data": "black"}
def fenetres(texte):
"""'T1/T2,T3/T4' -> [(début, fin)]."""
return [tuple(donnees.instant(b) for b in f.split("/")) for f in texte.split(",")] if texte else []
def dans(t, fen):
return any(a <= t <= b for a, b in fen)
def references(par, calme):
"""{capteur: {métrique: {heure: médiane, None: médiane toutes heures}}} sur les mesures calmes."""
ref = {}
for s, ms in par.items():
ref[s] = {}
for c in METRIQUES:
parh, tout = {}, []
for m in ms:
if m[c] is None or (calme and not dans(m["t"], calme)):
continue
parh.setdefault(m["t"].hour, []).append(m[c])
tout.append(m[c])
r = {h: statistics.median(v) for h, v in parh.items()}
r[None] = statistics.median(tout) if tout else None
ref[s][c] = r
return ref
def rapport(ref, s, c, m):
r = ref[s][c].get(m["t"].hour, ref[s][c][None])
return m[c] / r if m[c] is not None and r else None
def touche(r, c, seuil):
return r is not None and ((c in ("flux", "snr") and r < seuil) or (c == "dominance" and r > 1 / seuil))
def med(v):
return f"{statistics.median(v):.2f}" if v else "-"
def resume(par, ref, noms, refs, pmax):
print(f"peak maximal du dossier : {pmax if pmax is None else f'{pmax:g}'} ; pk/max : peak médian du capteur sur la "
"fenêtre, divisé par ce maximum")
print("Résumé : rapport médian à la référence calme, puis l'extrême et son instant (UTC)")
print(f"{'capteur':>12} {'rej':>4} {'pk/max':>6} " + " ".join(f"{c:>26}" for c in METRIQUES))
meds = {c: {"cibles": [], "références": []} for c in METRIQUES}
for s in noms:
ms = par[s]
if not ms:
continue
cases = []
for c in METRIQUES:
rs = [(rapport(ref, s, c, m), m["t"]) for m in ms]
rs = [x for x in rs if x[0] is not None]
if not rs:
cases.append(f"{'vide':>26}")
continue
md = statistics.median(r for r, _ in rs)
ext = (max if c in HAUT_MAUVAIS else min)(rs, key=lambda x: x[0])
meds[c]["références" if s in refs else "cibles"].append(md)
cases.append(f"{md:6.2f} ({ext[0]:6.2f} {ext[1]:%d/%m %H:%M})")
rej = sum(1 for m in ms if donnees.rejetee(m))
pk = [m["peak"] for m in ms if m["peak"] is not None]
pk = f"{statistics.median(pk) / pmax:6.2f}" if pk and pmax else f"{'-':>6}"
print(f"{s + ('r' if s in refs else ''):>12} {rej:>4} {pk} " + " ".join(cases))
for g in ("cibles", "références"):
print(f"{g:>24} " + " ".join(f"{statistics.median(meds[c][g]):26.2f}" if meds[c][g] else f"{'-':>26}"
for c in METRIQUES))
def par_pas(par, noms, pas):
pas = duree(pas)
debut = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0)
return lambda t: debut + (t - debut) // pas * pas
def table(par, ref, noms, c, pas, seuil):
cle, cases = par_pas(par, noms, pas), {}
for s in noms:
for m in par[s]:
r = rapport(ref, s, c, m)
if r is not None:
cases.setdefault(cle(m["t"]), {}).setdefault(s, []).append((r, donnees.rejetee(m)))
haut = c in HAUT_MAUVAIS
print(f"\nTable de {c} / référence, pas de {pas} ('*' : une mesure du pas rejetée)")
w = max(7, *map(len, noms))
entete = f"{'instant':16} " + " ".join(f"{s:>{w}}" for s in noms) + f" {'méd':>6} {'n' + ('>' if haut else '<') + str(seuil):>6}"
for i, k in enumerate(sorted(cases)):
if i % 24 == 0:
print(entete)
ligne, vals = [], []
for s in noms:
v = cases[k].get(s)
if not v:
ligne.append(f"{'':>{w}}")
continue
r = statistics.median(x for x, _ in v)
vals.append(r)
ligne.append(f"{r:{w - 1}.2f}" + ("*" if any(j for _, j in v) else " "))
n = sum(1 for r in vals if (r > 1 / seuil if haut else r < seuil))
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(ligne) + f" {statistics.median(vals):6.2f} {n:>6}")
def commun(par, ref, noms, refs, pas):
"""Par pas : médiane des rapports des cibles, puis des références, pour chaque métrique."""
cle, cases = par_pas(par, noms, pas), {}
for s in noms:
for m in par[s]:
d = cases.setdefault(cle(m["t"]), {c: ([], []) for c in METRIQUES})
for c in METRIQUES:
r = rapport(ref, s, c, m)
if r is not None:
d[c][s in refs].append(r)
print(f"\nMédianes des rapports par pas de {pas} : cibles / références")
entete = f"{'instant':16} " + " ".join(f"{c:>13}" for c in METRIQUES)
for i, k in enumerate(sorted(cases)):
if i % 24 == 0:
print(entete)
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(
f"{statistics.median(cases[k][c][0]) if cases[k][c][0] else float('nan'):6.2f}/"
f"{statistics.median(cases[k][c][1]) if cases[k][c][1] else float('nan'):<6.2f}" for c in METRIQUES))
def lire_etiquettes(chemin):
return [json.loads(ligne) for ligne in open(chemin) if ligne.strip()]
def etiquettes(a, tout, ref, refs, noms, deb, fin):
marge = timedelta(minutes=a.marge)
temps = {s: [m["t"] for m in tout[s]] for s in noms}
garder = {int(n) for n in a.numeros.split(",")} if a.numeros else None
print(f"Référence calme : {a.calme or 'tout le dossier'} ; rapports médians avant|plage|après ({a.marge} min)")
for n, e in enumerate(lire_etiquettes(a.etiquettes), 1):
t0, t1 = donnees.instant(e["debut"]), donnees.instant(e["fin"])
if (garder and n not in garder) or (deb and t0 < deb) or (fin and t0 > fin):
continue
print(f"\n{n}. {e['debut']} → {e['fin']}, {e['categorie']}")
win = {s: tout[s][bisect.bisect_left(temps[s], t0 - marge):bisect.bisect_right(temps[s], t1 + marge)] for s in noms}
parties = [(t0 - marge, t0 - timedelta(seconds=1)), (t0, t1), (t1 + timedelta(seconds=1), t1 + marge)]
for c in METRIQUES:
cases = []
for g in (False, True):
vals = []
for a0, a1 in parties:
v = [rapport(ref, s, c, m) for s in win if (s in refs) == g for m in win[s] if a0 <= m["t"] <= a1]
vals.append(med([x for x in v if x is not None]))
cases.append(("ref " if g else "cib ") + "|".join(vals))
print(f" {c:>9} " + " ".join(cases))
pires = []
for s in noms:
ms = [m for m in win[s] if t0 <= m["t"] <= t1]
if any(touche(rapport(ref, s, c, m), c, a.seuil) for m in ms for c in ("flux", "snr", "dominance")):
fl = [x for x in (rapport(ref, s, "flux", m) for m in ms) if x is not None]
pires.append((min(fl) if fl else 1, s + ("r" if s in refs else "")))
pires.sort()
print(f" touchés ({len(pires)}) : " + ", ".join(f"{s} {f:.2f}" for f, s in pires) if pires else " touchés : aucun")
if a.bords:
inst = {}
for s in win:
for m in win[s]:
d = inst.setdefault(m["t"], {"n": 0, "flux": [], "snr": [], "dominance": []})
rs = {c: rapport(ref, s, c, m) for c in ("flux", "snr", "dominance")}
d["n"] += any(touche(rs[c], c, a.seuil) for c in rs)
if s not in refs:
for c in rs:
if rs[c] is not None:
d[c].append(rs[c])
print(" instant n flux snr dom")
for t in sorted(inst):
d = inst[t]
print(f" {t:%Y-%m-%d %H:%M} {d['n']:>3} {med(d['flux']):>5} {med(d['snr']):>5} {med(d['dominance']):>5}"
+ (" <" if t0 <= t <= t1 else ""))
def hors(a, tout, ref, refs, noms, deb, fin):
sauf = set(a.sauf.split(",")) if a.sauf else set()
couvert = [(donnees.instant(e["debut"]), donnees.instant(e["fin"])) for e in lire_etiquettes(a.etiquettes)
if e["categorie"] not in sauf]
inst = {}
for s in noms:
for m in donnees.filtrer(tout[s], deb, fin):
if dans(m["t"], couvert):
continue
if any(touche(rapport(ref, s, c, m), c, a.seuil) for c in ("flux", "snr", "dominance")):
inst.setdefault(m["t"], {})[s + ("r" if s in refs else "")] = rapport(ref, s, "flux", m) or 0
suites = []
for t in sorted(t for t in inst if len(inst[t]) >= a.min):
if suites and t - suites[-1][-1] <= timedelta(minutes=15):
suites[-1].append(t)
else:
suites.append([t])
print(f"Hors des étiquettes (sauf {a.sauf}) : instants où au moins {a.min} capteurs sont touchés ; {len(suites)} suites")
for su in suites:
pire = {}
for t in su:
for s, f in inst[t].items():
pire[s] = min(pire.get(s, 9), f)
print(f"{su[0]:%Y-%m-%d %H:%M} → {su[-1]:%H:%M} ({len(su)}) : "
+ ", ".join(f"{s} {f:.2f}" for s, f in sorted(pire.items(), key=lambda x: x[1])))
def morceaux(pts, trou=timedelta(minutes=30)):
"""[(t, ...)] -> listes coupées là où deux instants sont à plus de `trou` : un trait ne traverse pas un trou de mesures."""
out = []
for i, x in enumerate(pts):
if not out or x[0] - pts[i - 1][0] > trou:
out.append([])
out[-1].append(x)
return out
def figure(a, par, ref, noms, refs, deb, fin):
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
plages = [(x, y, "grey") for x, y in fenetres(",".join(a.zone or []))]
if a.etiquettes:
for e in lire_etiquettes(a.etiquettes):
x, y = donnees.instant(e["debut"]), donnees.instant(e["fin"])
if (deb is None or y >= deb) and (fin is None or x <= fin):
plages.append((x, y, COULEURS.get(e["categorie"], "grey")))
station = os.path.basename(os.path.normpath(a.dossier))
t0 = min(m["t"] for s in noms for m in par[s])
t1 = max(m["t"] for s in noms for m in par[s])
suffixe = f"{t0:%Y%m%dT%H%MZ}_{t1:%Y%m%dT%H%MZ}"
os.makedirs(a.sortie, exist_ok=True)
def axe(ax):
for x, y, couleur in plages:
ax.axvspan(x, y, color=couleur, alpha=0.12, lw=0)
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%M"))
ax.set_yscale("log")
ax.axhline(1, ls=":", c="k", lw=0.8)
ax.set_xlim(t0, t1)
fig, axes = plt.subplots(len(METRIQUES), 1, figsize=(16, 2.4 * len(METRIQUES)), sharex=True)
for ax, c in zip(axes, METRIQUES):
inst = {}
for s in noms:
for m in par[s]:
r = rapport(ref, s, c, m)
if r is not None and r > 0:
inst.setdefault(m["t"], ([], []))[s in refs].append(r)
ts = sorted(inst)
cib = [(t, sorted(inst[t][0])) for t in ts if inst[t][0]]
rfs = [(t, statistics.median(inst[t][1])) for t in ts if inst[t][1]]
for i, mc in enumerate(morceaux(cib)):
ax.fill_between([t for t, _ in mc], [v[len(v) // 10] for _, v in mc], [v[(len(v) * 9) // 10] for _, v in mc],
color="0.8", lw=0, step="mid")
ax.plot([t for t, _ in mc], [statistics.median(v) for _, v in mc], c="k", lw=0.7,
label="cibles (médiane, bande 10-90 %)" if i == 0 else None)
for i, mc in enumerate(morceaux(rfs)):
ax.plot([t for t, _ in mc], [v for _, v in mc], c="tab:red", lw=0.7, label="références (médiane)" if i == 0 else None)
axe(ax)
ax.set_ylabel(c)
axes[0].legend(loc="upper right", fontsize=8)
axes[0].set_title(f"{station} : métriques de qualité / référence calme ({a.calme or 'tout le dossier'}), même heure UTC")
chemin = os.path.join(a.sortie, f"{station}_qualite-commun_{suffixe}.png")
fig.tight_layout()
fig.savefig(chemin, dpi=90)
plt.close(fig)
print(chemin)
for c in a.metriques.split(","):
col = 6
lig = (len(noms) + col - 1) // col
fig, axes = plt.subplots(lig, col, figsize=(3.2 * col, 1.9 * lig), sharex=True, squeeze=False)
for ax, s in zip(axes.flat, noms):
pts = [(m["t"], rapport(ref, s, c, m)) for m in par[s]]
pts = [(t, r) for t, r in pts if r is not None and r > 0]
for mc in morceaux(pts):
ax.plot([t for t, _ in mc], [r for _, r in mc], lw=0.5, c="tab:red" if s in refs else "k")
axe(ax)
ax.set_title(s, fontsize=8, color="tab:red" if s in refs else "k")
ax.tick_params(labelsize=6)
for ax in list(axes.flat)[len(noms):]:
ax.axis("off")
fig.suptitle(f"{station} : {c} / référence calme, par capteur (références en rouge)")
chemin = os.path.join(a.sortie, f"{station}_qualite-{c}_{suffixe}.png")
fig.tight_layout()
fig.savefig(chemin, dpi=80)
plt.close(fig)
print(chemin)
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("dossier")
p.add_argument("--debut", type=donnees.instant)
p.add_argument("--fin", type=donnees.instant)
p.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
p.add_argument("--calme", help="fenêtres de la référence, T1/T2,T3/T4 (défaut : tout le dossier)")
p.add_argument("--commun", action="store_true", help="médianes des cibles et des références par pas")
p.add_argument("--table", choices=METRIQUES, help="rapport d'une métrique par pas et par capteur")
p.add_argument("--pas", default="15min", type=lambda x: duree(x) and x, help="15min, 1h, 1d")
p.add_argument("--seuil", type=float, default=0.5, help="« touché » : flux ou snr sous seuil, dominance au-dessus de 1/seuil")
p.add_argument("--etiquettes", help="fichier d'étiquettes (JSON par ligne)")
p.add_argument("--numeros", help="numéros d'étiquettes à lire, 3,7")
p.add_argument("--marge", type=int, default=60, help="minutes avant et après chaque étiquette")
p.add_argument("--bords", action="store_true")
p.add_argument("--hors", action="store_true", help="instants touchés qu'aucune étiquette ne couvre")
p.add_argument("--min", type=int, default=1)
p.add_argument("--sauf", default="Thermal displacement", help="familles ignorées par --hors, A,B")
p.add_argument("--figure", action="store_true", help="PNG (matplotlib : .venv/bin/python)")
p.add_argument("--metriques", default="flux,snr,dominance", help="PNG par capteur de --figure")
p.add_argument("--zone", action="append", help="plage à griser sur les PNG, T1/T2 (répétable)")
p.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
a = p.parse_args()
if a.hors and not a.etiquettes:
p.error("--hors demande --etiquettes")
inconnues = [c for c in a.metriques.split(",") if c not in METRIQUES]
if inconnues:
p.error(f"métriques inconnues : {', '.join(inconnues)} ; connues : {', '.join(METRIQUES)}")
tout = donnees.charger(a.dossier)
if not tout:
sys.exit(f"Aucun export « advanced » dans {a.dossier} (voir inventaire.py).")
if not any(m[c] is not None for ms in tout.values() for m in ms for c in METRIQUES):
sys.exit(f"Aucune métrique de qualité dans {a.dossier} : peak à snr vides (caméra ancienne ; "
"labeling/connaissances/metriques-de-qualite.md).")
noms = a.capteurs.split(",") if a.capteurs else sorted(tout, key=lambda s: (not donnees.est_reference(tout[s]), s))
absents = [s for s in noms if s not in tout]
if absents:
sys.exit(f"Capteurs absents : {', '.join(absents)}. Présents : {', '.join(sorted(tout))}.")
ref = references(tout, fenetres(a.calme))
refs = {s for s in tout if donnees.est_reference(tout[s])}
par = {s: donnees.filtrer(tout[s], a.debut, a.fin) for s in noms}
if not any(par.values()):
sys.exit("Aucune mesure dans la fenêtre demandée.")
if a.figure:
return figure(a, par, ref, noms, refs, a.debut, a.fin)
if a.etiquettes:
return (hors if a.hors else etiquettes)(a, tout, ref, refs, noms, a.debut, a.fin)
pmax = max((m["peak"] for ms in tout.values() for m in ms if m["peak"] is not None), default=None)
print(f"Référence calme : {a.calme or 'tout le dossier'}, par heure UTC du jour (r = référence)")
resume(par, ref, noms, refs, pmax)
if a.commun:
commun(par, ref, noms, refs, a.pas)
if a.table:
table(par, ref, noms, a.table, a.pas, a.seuil)
def essai():
"""Contrôle du rapport à la référence : même heure, repli sur toutes les heures, fenêtre calme respectée."""
from datetime import datetime, timezone
t = lambda j, h: datetime(2026, 10, j, h, tzinfo=timezone.utc) # noqa: E731
vide = dict.fromkeys(METRIQUES)
par = {"A": [dict(vide, t=t(1, 3), flux=10.0), dict(vide, t=t(2, 3), flux=30.0), dict(vide, t=t(2, 5), flux=100.0),
dict(vide, t=t(9, 3), flux=1000.0)]}
ref = references(par, [(t(1, 0), t(3, 0))])
assert ref["A"]["flux"][3] == 20.0 and ref["A"]["flux"][None] == 30.0, ref
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 3), flux=10.0)) == 0.5
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 7), flux=60.0)) == 2.0 # heure sans calme : toutes les heures
assert rapport(ref, "A", "snr", dict(vide, t=t(9, 3), snr=5.0)) is None
assert touche(0.4, "flux", 0.5) and touche(2.5, "dominance", 0.5) and not touche(2.5, "flux", 0.5)
print("essai : ok")
if __name__ == "__main__":
essai() if sys.argv[1:] == ["--essai"] else main()
-124
View File
@@ -1,124 +0,0 @@
"""Résumé chiffré compact des séries d'un export « advanced », pour l'agent de diagnostic.
Usage : python3 agent-tools/resume.py data/PS_DES_COUDRES/ [--colonne error_value]
[--stat median|min|max] [--pas 1h] [--niveau periode|fenetre] [--capteurs CAPTEUR_A,CAPTEUR_B] [--debut 2026-01-01T00:00Z] [--fin ...]
[--instants T1,T2] [--marque]
1. Niveau habituel de chaque capteur : médiane, MAD (écart absolu médian), min, max, sur toute la période
(défaut) ou, avec --niveau fenetre, sur la fenêtre --debut/--fin seulement (un changement de niveau
dans la fenêtre ne se compare pas à des semaines d'autres mesures).
Colonnes : error_value, corr_x, corr_y, relative_x, relative_y, x, y, sigma0, reproj_err, et les six métriques de qualité d'image (peak à snr, valeurs brutes ; vides sur les
caméras anciennes ; face à une référence calme : qualite.py).
2. Tableau : une ligne par pas de temps (début du pas, UTC), une colonne par capteur, la statistique
choisie sur les mesures du pas. « rej » : toutes les mesures du pas sont rejetées ; « vide » : des mesures,
mais la colonne est vide (ex. reproj_err d'une cible) ; « - » : aucune mesure. L'en-tête des capteurs se répète
toutes les 24 lignes. Avec --instants T1,T2 : seulement les pas qui contiennent ces instants. Avec --marque : « * »
après la valeur quand une mesure du pas est rejetée (x, y, error_value d'une mesure rejetée restent remplis),
« o » quand une mesure du pas a inlier = 0 (référence écartée par la compensation).
Rend des valeurs, pas de verdict.
"""
import argparse
import re
import statistics
import sys
from datetime import timedelta
from donnees import charger, est_reference, filtrer, instant, iso, rejetee
COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err")
QUALITE = ("peak", "flux", "sharpness", "fwhm", "dominance", "snr") # qualité de l'image : caméras récentes ; lue par qualite.py
STATS = {"median": statistics.median, "min": min, "max": max}
def duree(texte):
"""'15min', '1h', '6h', '1d' -> timedelta."""
m = re.fullmatch(r"(\d+)(min|h|d)", texte)
if not m:
raise argparse.ArgumentTypeError(f"pas invalide : {texte!r} (ex. 15min, 1h, 1d)")
n, unite = int(m.group(1)), m.group(2)
return {"min": timedelta(minutes=n), "h": timedelta(hours=n), "d": timedelta(days=n)}[unite]
ARRONDI = 1e-9 # en deçà, un écart entre deux mesures est l'arrondi du calcul de la station, pas un bruit
def bruit_propre(vs):
"""Médiane des écarts absolus entre deux valeurs consécutives ; 0 quand elle est sous ARRONDI (valeurs constantes
à l'arrondi près : le corr des références quand la compensation passe exactement par elles, deux références
retenues), pour qu'un écart ne s'écrive pas en milliards de bruits ; 0 aussi avec moins de deux valeurs."""
d = [abs(b - a) for a, b in zip(vs, vs[1:])]
b = statistics.median(d) if d else 0
return b if b >= ARRONDI else 0
def valeurs(ms, col):
return [m[col] for m in ms if m[col] is not None]
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--colonne", default="error_value", choices=COLONNES + QUALITE)
a.add_argument("--stat", default="median", choices=STATS)
a.add_argument("--pas", default="1h", type=duree)
a.add_argument("--niveau", default="periode", choices=("periode", "fenetre"),
help="période sur laquelle médiane et MAD sont calculées (défaut : toutes les mesures)")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--instants", help="T1,T2 : seulement les pas qui contiennent ces instants")
a.add_argument("--marque", action="store_true", help="* : une mesure du pas rejetée ; o : une mesure du pas avec inlier = 0")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
o = a.parse_args()
par = charger(o.dossier)
if not par:
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
inconnus = [s for s in noms if s not in par]
if inconnus:
sys.exit(f"Capteurs absents : {', '.join(inconnus)}. Présents : {', '.join(sorted(par))}.")
t0 = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0)
cases = {}
for s in noms:
for m in filtrer(par[s], o.debut, o.fin):
debut_du_pas = t0 + ((m["t"] - t0) // o.pas) * o.pas
cases.setdefault(debut_du_pas, {}).setdefault(s, []).append(m)
if not cases:
sys.exit("Aucune mesure dans la fenêtre demandée.")
sur = "la fenêtre --debut/--fin" if o.niveau == "fenetre" else "toute la période"
print(f"Colonne : {o.colonne}. Niveau habituel sur {sur} (mesures non vides) :")
print(f"{'capteur':10} {'n':>5} {'médiane':>10} {'MAD':>10} {'min':>10} {'max':>10}")
for s in noms:
v = valeurs(filtrer(par[s], o.debut, o.fin) if o.niveau == "fenetre" else par[s], o.colonne)
if not v:
print(f"{s:10} {0:5} (aucune valeur)")
continue
med = statistics.median(v)
mad = statistics.median(abs(x - med) for x in v)
print(f"{s:10} {len(v):5} {med:10.5g} {mad:10.5g} {min(v):10.5g} {max(v):10.5g}")
print(f"\n{o.stat} de {o.colonne} par pas de {o.pas} (début du pas, UTC) :")
print("rej : mesures du pas toutes rejetées ; vide : colonne vide ; - : aucune mesure")
if o.marque:
print("* : une mesure du pas au moins est rejetée ; o : une mesure du pas au moins a inlier = 0")
entete = f"{'début':17} " + " ".join(f"{s:>9}" for s in noms)
voulus = {t0 + ((instant(x) - t0) // o.pas) * o.pas for x in o.instants.split(",")} if o.instants else None
for i, k in enumerate(k for k in sorted(cases) if voulus is None or k in voulus):
if i % 24 == 0:
print(entete)
cellules = []
for s in noms:
ms = cases[k].get(s, [])
v = valeurs(ms, o.colonne)
if v:
marque = ("*" if any(map(rejetee, ms)) else "") + ("o" if any(m["inlier"] == 0 for m in ms) else "") if o.marque else ""
cellules.append(f"{STATS[o.stat](v):.5g}{marque}".rjust(9))
else:
cellules.append(f"{'-' if not ms else 'rej' if all(map(rejetee, ms)) else 'vide':>9}")
print(f"{iso(k):17} " + " ".join(cellules))
if __name__ == "__main__":
main()
-194
View File
@@ -1,194 +0,0 @@
"""Plusieurs stations sur une même ligne de temps : température du boîtier, pose de la caméra, corr des cibles, rejets, trous.
Usage : .venv/bin/python agent-tools/stations.py data/BREITHORN data/MICHIGAN data/NEBRASKA
[--colonnes temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y] [--pas 1h] [--stat median|min|max]
[--table T1/T2|non] [--debut ...] [--fin ...] [--sortie DOSSIER]
Pour chaque station (un dossier de station chacune), sur la fenêtre --debut/--fin :
- colonnes possibles : temperature (médiane des composants sensor_*_deg_c, comme metriques.py), cam_pan, cam_tilt,
cam_rotation, cam_scale, cam_sigma0 (pose brute de la caméra), cib_corr_x, cib_corr_y (médiane sur les cibles de
corr moins le niveau propre de chaque cible, mesures acceptées, comme metriques.py), rej_cibles, rej_refs (nombre de
cibles, de références rejetées : le plus grand des instants de mesure du pas) ;
- imprime, par station, la période des mesures, la cadence (pas médian) et le nombre d'instants ; puis les **trous** :
les suites de pas de --pas sans mesure ou sans température, avec les stations où elles manquent (un trou commun à
plusieurs stations y est sur une seule ligne) ; puis la table, une ligne par pas (début du pas, UTC ; --stat des
valeurs du pas ; « - » : aucune valeur), une colonne par station et par colonne, séparées par des tabulations
(--table T1/T2 : seulement entre T1 et T2, « non » : pas du tout ; le reste porte sur toute la fenêtre) ; puis, pour
chaque colonne et chaque paire de stations, la corrélation r des valeurs et celle des pas (différence d'une valeur à
la suivante, sur les pas où les deux stations ont une valeur : un mouvement commun se voit sur les pas, une tendance
commune sur les valeurs), avec le nombre de pas ;
- un PNG « stations » : un panneau par colonne, un trait par station (température brute ; les autres colonnes moins
leur médiane sur la fenêtre, pour se superposer), coupé sur un trou ; trous de mesure grisés sous l'axe, une bande
par station.
Jamais d'identifiant de metrics/ (SIM_CCID, ip*) : seules les températures y sont lues. Rend des valeurs, pas de verdict.
"""
import argparse
import os
import statistics
import sys
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates # noqa: E402
import matplotlib.pyplot as plt # noqa: E402
from donnees import POSE, charger, charger_camera, charger_temperature, est_reference, filtrer, instant, iso, rejetee # noqa: E402
from graphique import RACINE, borne # noqa: E402
from metriques import cibles, coupe, suites # noqa: E402
from resume import STATS, duree # noqa: E402
COLONNES = ("temperature",) + tuple("cam_" + c for c in POSE) + ("cib_corr_x", "cib_corr_y", "rej_cibles", "rej_refs")
def lire(dossier, debut, fin):
"""Dossier de station -> ({colonne: [{'t', 'v'}]}, [instants de mesure])."""
par = charger(dossier)
series = {"temperature": filtrer([{"t": t, "v": v} for t, v in charger_temperature(dossier)], debut, fin)}
for p in filtrer(charger_camera(dossier), debut, fin):
for c in POSE:
if p[c] is not None:
series.setdefault("cam_" + c, []).append({"t": p["t"], "v": p[c]})
for c in ("corr_x", "corr_y"):
series["cib_" + c] = cibles(par, c, debut, fin)
rej = {} # t -> [cibles rejetées, références rejetées]
for s, ms in par.items():
ref = est_reference(ms)
for m in filtrer(ms, debut, fin):
n = rej.setdefault(m["t"], [0, 0])
n[ref] += rejetee(m)
series["rej_cibles"] = [{"t": t, "v": float(n[0])} for t, n in sorted(rej.items())]
series["rej_refs"] = [{"t": t, "v": float(n[1])} for t, n in sorted(rej.items())]
return series, sorted(rej)
def correlation(a, b):
try:
return f"{statistics.correlation(a, b):+.2f}"
except (statistics.StatisticsError, ValueError):
return "-"
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossiers", nargs="+", help="dossiers de station, au moins deux")
a.add_argument("--colonnes", default="temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y")
a.add_argument("--pas", default="1h", type=duree)
a.add_argument("--stat", default="median", choices=STATS)
a.add_argument("--table", default="", metavar="T1/T2|non", help="table imprimée seulement entre T1 et T2 (« non » : pas du tout)")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
o = a.parse_args()
colonnes = o.colonnes.split(",")
if absents := [c for c in colonnes if c not in COLONNES]:
sys.exit(f"Colonnes inconnues : {', '.join(absents)}. Connues : {', '.join(COLONNES)}.")
if o.table in ("", "non"):
dans_table = lambda t: o.table == "" # noqa: E731
else:
bornes = [instant(x) for x in o.table.split("/")]
if len(bornes) != 2:
sys.exit("--table attend T1/T2 ou non.")
dans_table = lambda t: bornes[0] <= t <= bornes[1] # noqa: E731
noms = [os.path.basename(os.path.normpath(d)) for d in o.dossiers]
donnees, mesures = {}, {}
for n, d in zip(noms, o.dossiers):
donnees[n], mesures[n] = lire(d, o.debut, o.fin)
tous = [p["t"] for s in donnees.values() for c in s.values() for p in c]
if not tous:
sys.exit("Aucune valeur dans la fenêtre demandée.")
t0 = (o.debut or min(tous)).replace(minute=0, second=0, microsecond=0)
t1 = o.fin or max(tous)
grille = [t0 + i * o.pas for i in range(int((t1 - t0) / o.pas) + 1)]
case = lambda t: t0 + ((t - t0) // o.pas) * o.pas # noqa: E731
print("Stations :")
for n in noms:
ts = mesures[n]
if not ts:
print(f" {n} : aucune mesure dans la fenêtre")
continue
cad = statistics.median(b - a_ for a_, b in zip(ts, ts[1:])) if len(ts) > 1 else None
print(f" {n} : mesures {iso(ts[0])} → {iso(ts[-1])}, {len(ts)} instants, cadence {round(cad.total_seconds() / 60) if cad else '-'} min ; "
+ ", ".join(f"{c} {len(donnees[n].get(c, []))}" for c in colonnes))
# trous : pas sans mesure, sans température, et les stations concernées
avec = {n: {case(t) for t in mesures[n]} for n in noms}
avec_t = {n: {case(p["t"]) for p in donnees[n]["temperature"]} for n in noms}
print(f"\nTrous (pas de {int(o.pas.total_seconds() // 60)} min sans mesure ou sans température), avec les stations où ils manquent :")
cles = {}
for k in grille:
m = tuple(n for n in noms if k not in avec[n])
t = tuple(n for n in noms if k not in avec_t[n])
if m or t:
cles.setdefault((m, t), []).append(k)
lignes = []
for (m, t), ks in cles.items():
for d, f, nb in suites(ks, o.pas):
lignes.append((d, f, nb, m, t))
for d, f, nb, m, t in sorted(lignes):
print(f" {iso(d)} → {iso(f)} ({nb} pas) : sans mesure {','.join(m) or '-'} ; sans température {','.join(t) or '-'}")
if not lignes:
print(" (aucun)")
stat = STATS[o.stat]
table = {} # (station, colonne) -> {pas: valeur}
for n in noms:
for c in colonnes:
cases = {}
for p in donnees[n].get(c, []):
cases.setdefault(case(p["t"]), []).append(p["v"])
table[n, c] = {k: stat(v) for k, v in cases.items()}
entete = [f"{n}:{c}" for n in noms for c in colonnes]
print(f"\n{o.stat} par pas de {int(o.pas.total_seconds() // 60)} min (début du pas, UTC) ; « - » : aucune valeur"
+ (f" (table : {o.table})" if o.table else "") + " :")
if o.table != "non":
print("\t".join(["heure"] + entete))
for k in grille:
if dans_table(k):
v = [table[n, c].get(k) for n in noms for c in colonnes]
if any(x is not None for x in v):
print("\t".join([iso(k)] + ["-" if x is None else f"{x:.6g}" for x in v]))
print("\nCorrélation entre stations, r des valeurs, puis r des pas d'une valeur à la suivante (n : pas où les deux ont une valeur) :")
for c in colonnes:
for i, s1 in enumerate(noms):
for s2 in noms[i + 1:]:
ks = sorted(set(table[s1, c]) & set(table[s2, c]))
v1, v2 = [table[s1, c][k] for k in ks], [table[s2, c][k] for k in ks]
d1, d2 = [b - a_ for a_, b in zip(v1, v1[1:])], [b - a_ for a_, b in zip(v2, v2[1:])]
print(f" {c:12} {s1}-{s2} : r valeurs {correlation(v1, v2)}, r pas {correlation(d1, d2)} (n = {len(ks)})")
fig, axes = plt.subplots(len(colonnes) + 1, 1, sharex=True, figsize=(14, 2.4 * (len(colonnes) + 1)), squeeze=False,
layout="constrained", gridspec_kw={"height_ratios": [3] * len(colonnes) + [0.3 * len(noms)]})
for ax, c in zip(axes[:-1, 0], colonnes):
for i, n in enumerate(noms):
s = donnees[n].get(c, [])
if not s:
continue
med = 0 if c == "temperature" else statistics.median(p["v"] for p in s)
ts, vs = coupe([{"t": p["t"], "v": p["v"] - med} for p in s])
ax.plot(ts, vs, ".-", ms=2, lw=0.8, color=f"C{i % 10}", label=n)
ax.set_ylabel(c if c == "temperature" else f"{c}\nmoins sa médiane", fontsize=8)
ax.grid(alpha=0.3)
ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
ax = axes[-1, 0]
for i, n in enumerate(noms):
for k in grille:
if k not in avec[n]:
ax.axvspan(k, k + o.pas, ymin=i / len(noms), ymax=(i + 1) / len(noms), color=f"C{i % 10}", lw=0)
ax.set_yticks([(i + 0.5) / len(noms) for i in range(len(noms))], noms, fontsize=7)
ax.set_ylim(0, 1)
ax.set_ylabel("sans mesure", fontsize=8)
ax.set_xlim(grille[0], grille[-1] + o.pas)
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
fig.suptitle(f"{', '.join(noms)} : même ligne de temps (heures UTC)")
os.makedirs(o.sortie, exist_ok=True)
chemin = os.path.join(o.sortie, f"{'-'.join(noms)}_stations_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
fig.savefig(chemin, dpi=100, bbox_inches="tight")
print(f"\n{chemin}")
if __name__ == "__main__":
main()
-172
View File
@@ -1,172 +0,0 @@
"""Vignettes des images de la caméra autour de capteurs, à pleine résolution, pour l'agent de diagnostic.
Usage : .venv/bin/python agent-tools/vignettes.py data/PS_DES_COUDRES/
--capteurs REF_G,REF_D --heures 2026-10-13T22:00Z,2026-10-14T02:00Z [--rayon 100] [--contraste [MIN,MAX]] [--sortie DOSSIER]
Une ligne par capteur, une colonne par heure. Quand il n'y a pas d'image à l'heure demandée, la plus proche est
prise : l'écart est imprimé et l'heure réelle de l'image est dans le titre de la vignette. Chaque vignette est centrée sur la position brute (x, y) du capteur
dans l'export « advanced », lue à la mesure la plus proche de l'image ; les pixels ne sont pas retouchés, l'éclat
se compare donc d'une vignette à l'autre. Imprime les positions utilisées, le fond (médiane des pixels de la
vignette), le 99e centile et le pic (maximum) du niveau de gris de chaque vignette (0 à 255), puis le chemin du PNG.
--contraste : toutes les vignettes en niveaux de gris, avec le même étirement pour toute la planche, pour qu'une
tache faible se voie et se compare d'une vignette à l'autre. Sans valeur, l'étirement va du 1er centile au maximum
de la planche (un pixel saturé quelque part l'écrase : redonner alors --contraste MIN,MAX, en s'aidant du fond et du
pic imprimés pour chaque vignette). Un --rayon plus petit (30 à 50) grossit. Les bornes sont imprimées.
Le centre du cadre (px) est écrit sous chaque vignette : quand les x, y de l'export sautent, le cadre se déplace
d'autant. --fixe garde, sur chaque ligne, le cadre centré sur la position de la première heure demandée, et marque
d'une croix rouge les x, y de l'export à chaque heure : une tache qui entre dans le cadre ou en sort ne s'y confond
pas avec une tache qui apparaît. Un cadre que le bord de l'image coupe est signalé (taille de l'image) : sur certains
exports, x, y ne sont pas des pixels (valeurs proches de 0), et le cadre tombe dans le coin de l'image.
--zone X,Y,L,H : la même zone de l'image (pixels de l'image d'origine : coin haut gauche, largeur, hauteur, comme
gif.py) à chaque heure, côte à côte (jusqu'à 4 par ligne, moins quand la zone est large), même étirement avec --contraste ; --capteurs devient facultatif :
ceux qui sont donnés sont marqués d'une croix rouge et de leur nom à leurs x, y de chaque heure. Pour la scène autour
des cibles (premier plan, objet, éclairage), qu'un grand --rayon rendrait trop petite.
Chaque vignette est rendue à sa taille en pixels (un pixel de l'image pour un pixel du PNG) de 260 à 1000 px de côté ;
Read réduit un PNG trop large : avec un grand --rayon ou une grande --zone, peu d'heures par planche.
"""
import argparse
import os
import sys
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt # noqa: E402
from donnees import charger, heure_image, instant, iso, trouver # noqa: E402
def centile(gris, p):
"""Centile p (0 à 100) des pixels d'une vignette, sans interpolation."""
v = sorted(gris.ravel().tolist())
return v[min(int(p / 100 * len(v)), len(v) - 1)]
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--capteurs", default="", help="liste séparée par des virgules (facultative avec --zone)")
a.add_argument("--heures", required=True, help="heures des images, séparées par des virgules (UTC)")
a.add_argument("--rayon", type=int, default=100, help="demi-côté de la vignette en pixels (défaut 100)")
a.add_argument("--contraste", nargs="?", const="auto", metavar="MIN,MAX", help="niveaux de gris, même étirement pour toute la planche : MIN,MAX (0 à 255) ou, sans valeur, du 1er centile au maximum de la planche")
a.add_argument("--fixe", action="store_true", help="un cadre fixe par capteur (position à la première heure), x, y de chaque heure marqués d'une croix")
a.add_argument("--zone", metavar="X,Y,L,H", help="la même zone de l'image à chaque heure (pixels de l'image d'origine : coin haut gauche, largeur, hauteur)")
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
o = a.parse_args()
par = charger(o.dossier)
images = {heure_image(p): p for p in trouver(o.dossier)["images"]}
noms, heures = [s for s in o.capteurs.split(",") if s], [instant(h) for h in o.heures.split(",")]
zone = tuple(map(int, o.zone.split(","))) if o.zone else None
if not noms and not zone:
sys.exit("Donne --capteurs, ou --zone X,Y,L,H.")
absents = [s for s in noms if s not in par]
if absents:
sys.exit(f"Capteurs inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(par))}.")
connues = sorted(h for h in images if h)
if not connues:
sys.exit(f"Aucune image dans {o.dossier}.")
proche = {h: min(connues, key=lambda i: abs(i - h)) for h in heures} # image à l'heure demandée, sinon la plus proche
for h in heures:
if proche[h] != h:
print(f"Pas d'image à {iso(h)} : la plus proche est celle de {iso(proche[h])} (écart {abs(proche[h] - h)}).")
def niveaux(c):
gris = c[..., :3].mean(axis=-1) if c.ndim == 3 else c
return gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris
def mesure(s, t):
return min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - t))
r = o.rayon
coupes, centres, croix = {}, {}, {}
for j, h in enumerate(heures):
img = plt.imread(images[proche[h]])
haut, larg = img.shape[:2]
if zone:
X, Y, L, H = zone
c = img[max(Y, 0):Y + H, max(X, 0):X + L]
if c.size == 0:
sys.exit(f"--zone {o.zone} hors de l'image ({larg} × {haut} px).")
gris = niveaux(c)
coupes[0, j] = (c, gris)
croix[0, j] = [(s, m["x"] - max(X, 0), m["y"] - max(Y, 0)) for s in noms for m in [mesure(s, proche[h])]]
print(f"zone {o.zone} {iso(h)} : {os.path.basename(images[proche[h]])}, fond {centile(gris, 50):.0f}, "
f"p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}"
+ ("" if c.shape[:2] == (H, L) else f", coupée par le bord de l'image ({larg} × {haut} px)")
+ "".join(f" ; {s} x={x + max(X, 0):.1f} y={y + max(Y, 0):.1f}" for s, x, y in croix[0, j]))
continue
for i, s in enumerate(noms):
m = mesure(s, proche[h])
x, y = centres[i] if o.fixe and j else (round(m["x"]), round(m["y"]))
if j == 0:
centres[i] = (x, y)
c = img[max(y - r, 0):y + r, max(x - r, 0):x + r]
if c.size == 0:
sys.exit(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} hors de l'image ({larg} × {haut} px) ; "
"--zone X,Y,L,H regarde une zone fixe.")
croix[i, j] = (m["x"] - max(x - r, 0), m["y"] - max(y - r, 0), x, y)
gris = niveaux(c)
coupes[i, j] = (c, gris)
coupe = x - r < 0 or y - r < 0 or x + r > larg or y + r > haut
print(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} (mesure de {iso(m['t'])}), {os.path.basename(images[proche[h]])}, "
f"fond {centile(gris, 50):.0f}, p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}"
+ (f", cadre coupé par le bord de l'image ({larg} × {haut} px)" if coupe else ""))
bornes = {}
if o.contraste:
if o.contraste == "auto":
bornes = dict(vmin=min(centile(g, 1) for _, g in coupes.values()), vmax=max(g.max() for _, g in coupes.values()))
else:
bornes = dict(zip(("vmin", "vmax"), map(float, o.contraste.split(","))))
print(f"Étirement commun : {bornes['vmin']:.0f} à {bornes['vmax']:.0f} (niveaux de gris, 0 à 255)")
# Une vignette à sa taille en pixels (à 100 dpi) dès qu'elle dépasse 2,6 pouces : un grand --rayon n'est plus réduit.
cote = max(c.shape[1] for c, _ in coupes.values()) / 100, max(c.shape[0] for c, _ in coupes.values()) / 100
cote = tuple(v * min(1, 10 / max(cote)) for v in cote) # au plus 1000 px de côté par vignette
if zone:
nc = max(1, min(4, len(heures), int(20 // max(2.6, cote[0])))) # planche d'au plus ~2000 px de large : Read la réduit au-delà
nl = -(-len(heures) // nc)
fig, axes = plt.subplots(nl, nc, figsize=(max(2.6, cote[0]) * nc, (max(2.6, cote[1]) + 0.4) * nl), squeeze=False)
for ax in axes.ravel()[len(heures):]:
ax.axis("off")
else:
fig, axes = plt.subplots(len(noms), len(heures), figsize=(max(2.6, cote[0]) * len(heures), (max(2.6, cote[1]) + 0.2) * len(noms)), squeeze=False)
for (i, j), (c, gris) in coupes.items():
ax = axes[j // nc, j % nc] if zone else axes[i, j]
if o.contraste:
ax.imshow(gris, cmap="gray", interpolation="nearest", **bornes)
else:
ax.imshow(c, interpolation="nearest")
ax.set_title(f"{'zone' if zone else noms[i]} {proche[heures[j]].strftime('%d/%m %H:%MZ')}" + ("" if proche[heures[j]] == heures[j] else " (demandée " + heures[j].strftime('%H:%MZ') + ")"), fontsize=9)
if zone:
for s, cx, cy in croix[i, j]:
ax.plot(cx, cy, "+", color="r", ms=10, mew=1)
ax.annotate(s, (cx, cy), xytext=(4, 4), textcoords="offset points", color="r", fontsize=7)
ax.set_xlim(-0.5, c.shape[1] - 0.5)
ax.set_ylim(c.shape[0] - 0.5, -0.5)
ax.set_xlabel(f"zone {o.zone}", fontsize=7)
ax.set_xticks([])
ax.set_yticks([])
continue
cx, cy, x, y = croix[i, j]
if o.fixe:
ax.plot(cx, cy, "+", color="r", ms=10, mew=1)
ax.set_xlabel(f"centre du cadre {x}, {y}" + (f"\nx, y {cx + max(x - r, 0):.1f}, {cy + max(y - r, 0):.1f}" if o.fixe else ""), fontsize=7)
ax.set_xticks([])
ax.set_yticks([])
station = os.path.basename(os.path.normpath(o.dossier))
fig.suptitle(f"{station} : zone {o.zone} (x, y, largeur, hauteur en px ; heures UTC)" if zone else
f"{station} : vignettes de {2 * r} px autour de chaque capteur (heures UTC)", fontsize=10)
os.makedirs(o.sortie, exist_ok=True)
quoi = f"zone{o.zone.replace(',', '-')}" + ("_" + "-".join(noms) if noms else "") if zone else "-".join(noms)
sortie = os.path.join(o.sortie, f"{station}_vignettes_{quoi}_"
f"{'-'.join(h.strftime('%d%H%M') for h in heures)}{'_contraste' if o.contraste else ''}{'_fixe' if o.fixe else ''}.png")
fig.savefig(sortie, dpi=100, bbox_inches="tight")
print(sortie)
if __name__ == "__main__":
main()
+29 -29
View File
@@ -1,45 +1,45 @@
# La web app AIMsight
# The AIMsight web app
L'outil du diagnostic manuel : une seule page, **Data**.
The tool of the manual diagnostic: a single page, **Data**.
## La page Data
## The Data page
- **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/<STATION>.jsonl`, en lecture seule ;
- **Analysis** : les mêmes étiquettes, à modifier ou supprimer ; écrit dans `labeling/auto/<STATION>.jsonl`.
- **The plots**: one at the start (displacements, camera, image quality, system metrics), "Add a plot" to see several, aligned in time, the cross to remove one; a click on a curve sets the images to the image nearest to that moment. The zones of the labels are barely visible there (opacity 0.05, 0.07 in dark mode).
- **The labels**, under the plots, and their bar, according to the chosen source:
- **Detectors** (default): the detectors' events (`detectors/scripts/categories.py`, `events`), read-only. The bar carries only their family, the tooltip their targets; on click: their dates, their sensors (targets and references), the message (the first sentence of the text of the event, `categories.sentence`) and the action (the "For the client" column of `labeling/families.md`, refined per kind, `station.ACTION_KIND`);
- **LLM**: `labeling/auto/<STATION>.jsonl`, read-only;
- **Analysis**: the same labels, to edit or delete; writes in `labeling/auto/<STATION>.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`).
With Detectors and LLM, dragging on the bar zooms in time; with Analysis, it selects a range to analyze. A click highlights a label on the plots and the bar, sets the images to its start and opens it (with Analysis: bounds, family, text, Save, Delete); a click elsewhere on the bar closes it. The page does not show `labeling/manual/`.
- **The camera images**, on the right, on the same station and the same range: slider, ◀ ▶ and keyboard arrows; wheel to zoom, drag to move, double click for the whole image; Names box; a range on the bar under the slider draws the displacement arrow of each sensor. An arrow at the top left enlarges the image and pushes the plots to the left; the reverse arrow brings it back.
- **The diagnostic settings**, under the image: "Focus on event curves" (with an event open, the plots show only its sensors: those of the detectors, or those the text of a label names), the families shown and, for Detectors only, the targets considered, the others removed before the detectors ("Rerun the detectors", parameter `targets` of `/api/detectors`).
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.
The address keeps the station and the range (UTC, `end` excluded): `#/data?station=NIEDERHORN&start=2026-09-25&end=2026-10-08`; without dates, the last 5 UTC days, today included.
## L'onglet Analysis
## The Analysis tab
- **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/<STATION>_<début>_<fin>/` 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/<STATION>.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 (`<analyse>/detectors/<heure>/summary.md`, puis `<analyse>/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.
- **Analyze the range**: a range selected, optional hints, then `server/analysis.py` launches the analyst of the agents repository by `claude -p` (non-interactive), with its instructions (`instructions/analyst.md`) and without the detectors (`DETECTORS: no`). It writes in `labeling/auto/analyses/<STATION>_<start>_<end>/` its labels and a diagnostic report (`report.md` and its figures; its work and claude's log in `work/`, outside git). The page follows its progress, then shows the report; the server submits its labels to `labeling/auto/<STATION>.jsonl` (field `analysis`). "View the report" on such a label opens it again.
- **The sidebar** sorts the analyses of `labeling/auto/analyses/` into folders, one per station (open by default if it has one running), and inside one analysis per range, the most recent first, with its state; a click opens Data on it.
- **The messages**: after the report, the user writes to the analyst, the same session resumes (`--resume`). An analysis stops with the server ("interrupted"); "continue" in the message field resumes it.
- **Optimize the detectors**, on a finished analysis: `/improve` in Optimizer (`optimizer/`, with the plugin `agents/`) on the range of the analysis, then the `tool-builder` of the agents repository; the detectors committed in `detectors/`, the reading tools in `tools/`, each on its current branch. The page follows the thread of the session (`work/optimization.jsonl`), then shows its summary under the report (`optimizer/sessions/<analysis>_<time>/summary.md`, then `<analysis>/tools.md`). One optimization at a time; meanwhile, no analysis and no message to the analyst; an optimization cut by the server stopping is rerun with the button. The detectors' events are kept in memory until the end of an optimization: after an `/improve` run outside the app, restart the server.
## Lancer
## Launch
La tâche VS Code **Run app** (`.vscode/tasks.json`), ou à la main (Node 22 pour le front) :
The VS Code task **Run app** (`.vscode/tasks.json`), or by hand (Node 22 for the front end):
```bash
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
cd app/web && npm install && npm run build # once, and after each change of the page
.venv/bin/python app/server/server.py # .venv: see the README at the root
```
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é.
The page opens on `http://127.0.0.1:8770`. Settings by variables: `AIMSIGHT_DATA` (data, default `data/`), `AIMSIGHT_LABELS` (labels, default `labeling/`), `AIMSIGHT_PORT` (8770). To work on the page: `npm run dev` in `app/web/` (http://localhost:5173), the Python server launched next to it.
## Les dossiers
## The folders
- `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/` (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/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.
- `server/server.py`: FastAPI; serves the built page and the API under `/api` (stations, images, curves, detectors, labels, analyses); answers only the pages of the workstation (local Host, declared JSON).
- `server/station.py`: the data of the Data page; read-only on `data/` (through `tools/scripts/data.py`), writes only in `labeling/{auto,manual}/`.
- `server/analysis.py`: the Analysis tab; launches `claude` with the agent `agents:analyst` (Read, Write, Bash allowed without asking); and the optimization, `/improve` in Optimizer (Read, Write, Edit, Bash, Agent) then the agent `agents:tool-builder` (Read, Write, Edit, Bash).
- `server/check.py`: checks, without calling claude: `.venv/bin/python app/server/check.py`.
- `web/`: React (Vite) and Mantine; `src/App.jsx` (header, sidebar, address), `src/pages/Data.jsx` (the page), `src/pages/Images.jsx` (the images, in Data), `src/common.jsx` (requests, selector), `src/main.jsx` (theme). Plotly, dressed in Mantine's colours, loads only with Data. `dist/` and `node_modules/` outside git.
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.
The computation of `server/station.py` (images, curves, labels) comes from tools of the Support-Agent repository, copied on 2026-11-05 (commit 6e9f69a); it now evolves here.
+317
View File
@@ -0,0 +1,317 @@
"""The Analysis tab of the Data page: the analyst of the agents repository (agents/, a plugin: --agent agents:analyst), launched
by `claude -p`, non-interactive, on a range chosen in the page, with the user's optional hints, its instructions
(instructions/analyst.md) and without the detectors (DETECTORS: no: its labels will be used to improve them). It writes in
labeling/auto/analyses/<STATION>_<start>_<end>/ its labels (labels.jsonl) and a diagnostic report (report.md, its figures
next to it); at the end, the server submits its labels to labeling/auto/<STATION>.jsonl, marked with their analysis (field
`analysis`). Then the user can write to it: the same session resumes (`claude -p --resume`), and its labels, if they
change, replace those it had submitted.
On a finished analysis, "Optimize" launches `/improve` in Optimizer (optimizer/, the skill that improves the detectors on the
range of the analysis, its labels as truth), then the tool-builder of the agents repository, which brings the analyst's
scripts into the reading tools (tools/); one optimization at a time, no analysis or message meanwhile; the summary of the
session (optimizer/sessions/<analysis>_<time>/summary.md) and that of the tools (<analysis>/tools.md) show under the report.
"""
import html
import json
import os
import subprocess
import threading
from datetime import date, datetime, timedelta, timezone
import markdown
import station
FOLDER = station.LABELS / "auto" / "analyses"
DETECTORS = station.ROOT / "detectors"
AGENTS = station.ROOT / "agents" # the plugin of the generic agents (~/agents)
OPTIMIZER = station.ROOT / "optimizer" # the Optimizer repository (~/Optimizer), where /improve runs
SESSIONS = OPTIMIZER / "sessions"
# the request of /improve (optimizer/README.md), paths relative to the root of Optimizer (its links data, labeling, detectors)
IMPROVE = """/improve DETECTORS: detectors/. STATION: data/{station}. FROM: {start}. TO: {end}. \
LABELS: labeling/auto/{station}.jsonl. REFERENCE: --labels labeling/auto --data data. FAMILIES: labeling/families.md. \
CONTEXT: labeling/auto/analyses/{name}/report.md. OUT: sessions/{name}_{time}/. Caller's context: Diagnostic-app, through \
Optimizer; read-only on data/ and labeling/; commit only in detectors/, on its current branch; do not commit OUT."""
REQUEST = """Station: data/{station}/. Range: {start} → {end} (UTC). Hints: {hints}. \
Output folder: {out}/. DETECTORS: no. INSTRUCTIONS: instructions/analyst.md."""
# name -> {"state": "running" | "done" | "error", "lines": [...], "submitted": n}; one analysis at a time per range
analyses, lock = {}, threading.Lock()
# name of the analysis -> {"state": "running" | "done" | "error", "lines": [...]}; one optimization at a time, all analyses
optimizations = {}
BUSY = "an optimization of the detectors is running"
ISOLATED = ["--setting-sources", "project,local", "--strict-mcp-config"] # no plugins, hooks or MCP servers of the workstation
def _env():
"""The environment of claude -p, without an API key: the agents run on the Claude subscription, never on a key."""
return {k: v for k, v in os.environ.items() if k not in ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN")}
def _optimizing():
return any(o["state"] == "running" for o in optimizations.values())
def launch(body):
st, start, end = body.get("station"), body.get("start"), body.get("end")
station._validate({"description": "-"}, start, end)
station.folder(st)
if not (AGENTS / ".claude-plugin" / "plugin.json").exists():
raise station.Refusal("no agents in agents/ (the link: README.md)")
name = f"{st}_{start[:16].replace(':', '')}_{end[:16].replace(':', '')}"
with lock:
if _optimizing():
raise station.Refusal(BUSY)
if analyses.get(name, {}).get("state") == "running":
raise station.Refusal("this range is already being analyzed")
out = FOLDER / name
if out.exists(): # a new analysis of the same range: the old one stays, next to it
name += datetime.now(timezone.utc).strftime("_%H%M%S")
out = FOLDER / name
hints = (body.get("hints") or "").strip()
request = {"station": st, "start": start, "end": end, "hints": hints}
analyses[name] = {"state": "running", "lines": [], "submitted": 0, "station": st, "request": request}
(out / "work").mkdir(parents=True)
(out / "request.json").write_text(json.dumps(request, ensure_ascii=False, indent=1), encoding="utf-8")
prompt = REQUEST.format(station=st, start=start, end=end, out=out.relative_to(station.ROOT), hints=hints or "none")
threading.Thread(target=work, args=(name, out, prompt), daemon=True).start()
return {"name": name}
def work(name, out, prompt, resume=None):
"""A turn of the analyst: the request, or a message of the user in the same session (resume: its id)."""
a = analyses[name]
try:
p = subprocess.Popen(["claude", "-p", prompt, "--plugin-dir", str(AGENTS), "--agent", "agents:analyst", *ISOLATED,
"--output-format", "stream-json", "--verbose",
"--allowedTools", "Read,Write,Bash", "--permission-mode", "acceptEdits", *station.links()]
+ (["--resume", resume] if resume else []),
cwd=station.ROOT, env=_env(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
with open(out / "work" / "log.jsonl", "a", encoding="utf-8") as log:
for line in p.stdout:
log.write(line)
a["lines"] += digest(line)
if '"subtype":"init"' in line: # the session, for the next messages
(out / "work" / "session").write_text(json.loads(line)["session_id"])
if p.wait():
raise RuntimeError(f"claude ended with code {p.returncode}")
a["submitted"] = submit(a["station"], name, out)
a["state"] = "done"
except Exception as e: # noqa: BLE001 — the error shows in the page, the server goes on
a["lines"].append(f"Error: {e}")
a["state"] = "error"
def message(name, body):
"""A message of the user to the analyst, after its report: the same session resumes (claude -p --resume)."""
text, out = (body.get("text") or "").strip(), FOLDER / name
state(name) # the name checked, the state read again after a restart
a, session = analyses[name], out / "work" / "session"
if not text or not session.exists():
raise station.Refusal("empty message, or the analysis has no session to resume")
with lock:
if _optimizing():
raise station.Refusal(BUSY)
if a["state"] == "running":
raise station.Refusal("the analyst is still working")
a["state"] = "running"
line = json.dumps({"type": "page", "text": text}, ensure_ascii=False) + "\n"
with open(out / "work" / "log.jsonl", "a", encoding="utf-8") as log:
log.write(line)
a["lines"] += digest(line)
prompt = (f"{text}\n\n(If you change your labels, rewrite {out.relative_to(station.ROOT)}/labels.jsonl in full, the "
"server will submit them again; if the diagnosis changes, update report.md.)")
threading.Thread(target=work, args=(name, out, prompt, session.read_text()), daemon=True).start()
return {}
def digest(line):
"""A line of the log -> what the page shows of it: the user's messages ("› "), the analyst's texts, its tools and their
command, one line each."""
try:
m = json.loads(line)
except json.JSONDecodeError:
return [line.strip()[:200]] if line.strip() else []
if m.get("type") == "page":
return [f"› {m['text']}"]
if m.get("type") != "assistant":
return []
out = []
for c in m["message"].get("content", []):
if c.get("type") == "text" and c["text"].strip():
out.append(c["text"].strip()[:300])
elif c.get("type") == "tool_use":
i = c.get("input", {})
out.append(f"{c['name']}: {i.get('command') or i.get('file_path') or ''}"[:200])
return out
def submit(st, name, out):
"""The labels of the analysis into labeling/auto/<STATION>.jsonl, with their id and the name of the analysis; if the
analyst changed them since the last submission, they replace those it had submitted -> their number."""
labels, copy = out / "labels.jsonl", out / "work" / "submitted.jsonl"
text = labels.read_text(encoding="utf-8") if labels.exists() else ""
new = []
for l in text.split("\n"):
if l.strip():
e = json.loads(l)
station._validate(e, e.get("start"), e.get("end"))
new.append({k: e[k] for k in ("start", "end", "family", "description") if k in e} | {"analysis": name})
if copy.exists() and copy.read_text(encoding="utf-8") == text:
return len(new)
# ponytail: removed then put back, the labels of the analysis lose the edits made in the page; keeping them would
# require matching them one by one
with lock:
f = station.label_file(st, "auto") # the other lines stay as they are
kept = [l for l in (f.read_text(encoding="utf-8").split("\n") if f.exists() else [])
if l.strip() and json.loads(l).get("analysis") != name]
station.assign_ids(st, [json.loads(l) for l in kept] + new)
temp = f.with_name(f.name + ".tmp")
temp.write_text("".join(l + "\n" for l in kept + [json.dumps(e, ensure_ascii=False) for e in new]), encoding="utf-8")
os.replace(temp, f)
copy.write_text(text, encoding="utf-8")
return len(new)
def state(name):
out = FOLDER / name
if "/" in name or name.startswith(".") or not out.is_dir():
raise station.Refusal("unknown analysis")
if name not in analyses: # after a restart of the server, only the folder is left: the thread is read again in the log
log = out / "work" / "log.jsonl"
lines = [r for l in open(log, encoding="utf-8") for r in digest(l)] if log.exists() else []
request = json.loads((out / "request.json").read_text(encoding="utf-8"))
analyses[name] = {"state": "done" if (out / "report.md").exists() else "interrupted", "lines": lines,
"submitted": None, "station": request["station"], "request": request}
a, r = analyses[name], out / "report.md"
return {"name": name, "state": a["state"], "lines": a["lines"], "submitted": a["submitted"],
"report": int(r.stat().st_mtime) if r.exists() else None,
"dialogue": (out / "work" / "session").exists(), "request": a["request"], "optimization": optimization(name)}
def list_analyses():
"""The history of the analyses (the sidebar), the most recent first: those of the server with their state, the others
read on disk (done with a report, otherwise interrupted: an analysis stops with the server)."""
out = []
for d in sorted(FOLDER.glob("*/request.json"), key=lambda f: f.parent.stat().st_mtime, reverse=True):
name = d.parent.name
a = analyses.get(name) or {"state": "done" if (d.parent / "report.md").exists() else "interrupted",
"request": json.loads(d.read_text(encoding="utf-8"))}
out.append({"name": name, "state": a["state"]} | a["request"])
return out
def file(name, path):
"""A file of the folder of the analysis (the report, its figures), never outside."""
f = (FOLDER / name / path).resolve()
if not f.is_file() or not f.is_relative_to(FOLDER.resolve()):
raise station.Refusal("unknown file")
return f
STYLE = """body{font:14px/1.55 Roboto,sans-serif;margin:0;padding:4px 2px;color:#212529;background:transparent}
h1{font-size:20px}h2{font-size:16px;margin-top:22px}img{max-width:100%;border:1px solid #dee2e6;border-radius:4px}
code{font-size:12px;background:#f1f3f5;padding:1px 4px;border-radius:3px}pre{overflow-x:auto}
table{border-collapse:collapse}td,th{border:1px solid #dee2e6;padding:3px 8px;text-align:left}
body.dark{color:#c9c9c9}body.dark code{background:#2e2e2e}body.dark td,body.dark th,body.dark img{border-color:#424242}"""
def _page(text, title, dark):
"""A markdown in HTML, in the style of the page; its relative images resolve in the folder of the address."""
body = markdown.markdown(text, extensions=["tables", "fenced_code"])
return (f"<!doctype html><meta charset=utf-8><title>{html.escape(title)}</title><style>{STYLE}</style>"
f"<body class='{'dark' if dark else ''}'>{body}</body>")
def report(name, dark):
"""report.md in HTML, served in the folder of the analysis: its relative images are found there."""
return _page(file(name, "report.md").read_text(encoding="utf-8"), name, dark)
# --- "Optimize": /improve in Optimizer on the analysis, then the tool-builder, by claude -p
def _summary_file(name):
"""The summary of the last session of this analysis, or None. The time pattern rules out the sessions of another
analysis of the same range (<name>_<HHMMSS>_<time>)."""
summaries = sorted(SESSIONS.glob(f"{name}_????????T????Z/summary.md")) # the order of the name is that of time
return summaries[-1] if summaries else None
def optimization(name):
"""-> None (never optimized) or {state, lines, summary: mtime of the last summary}. After a restart, the state is read
again in the stream: its last line {"type": "end"} says done or error; without it, the optimization was cut
(interrupted)."""
stream, s = FOLDER / name / "work" / "optimization.jsonl", _summary_file(name)
o = optimizations.get(name)
if o is None:
if not stream.exists():
return None
lines = stream.read_text(encoding="utf-8").splitlines()
end = json.loads(lines[-1]) if lines and lines[-1].startswith('{"type": "end"') else None
o = {"state": "interrupted" if end is None else end["state"], "lines": [r for l in lines for r in digest(l)]}
optimizations[name] = o
return {"state": o["state"], "lines": o["lines"], "summary": int(s.stat().st_mtime) if s else None}
def optimize(name):
"""The "Optimize" button on a finished analysis: the session in a thread; refused if an optimization or an analysis runs."""
if state(name)["state"] != "done":
raise station.Refusal("only a finished analysis can be optimized")
if not ((OPTIMIZER / ".claude" / "skills" / "improve" / "SKILL.md").exists()
and all((OPTIMIZER / link).exists() for link in ("data", "labeling", "detectors"))
and (AGENTS / ".claude-plugin" / "plugin.json").exists()):
raise station.Refusal("no Optimizer in optimizer/ or no agents in agents/ (the links: README.md)")
with lock:
if _optimizing():
raise station.Refusal(BUSY)
if any(a["state"] == "running" for a in analyses.values()):
raise station.Refusal("an analysis is running: the optimization waits for its end")
optimizations[name] = {"state": "running", "lines": []}
threading.Thread(target=optimize_thread, args=(name,), daemon=True).start()
return {}
def optimize_thread(name):
"""The two turns of the optimization, one after the other: the detectors (/improve, in Optimizer), then the reading
tools (the tool-builder, even if the detectors did not change)."""
o, out = optimizations[name], FOLDER / name
rel = os.path.relpath(out, station.ROOT)
(out / "work").mkdir(exist_ok=True)
with open(out / "work" / "optimization.jsonl", "a", encoding="utf-8") as stream:
try:
d = json.loads((out / "request.json").read_text(encoding="utf-8"))
request = IMPROVE.format( # TO excluded: the day after the end of the range, as in the page
station=d["station"], start=d["start"][:10], end=date.fromisoformat(d["end"][:10]) + timedelta(days=1),
name=name, time=f"{datetime.now(timezone.utc):%Y%m%dT%H%MZ}")
# ponytail: Optimizer reads data/ and labeling/ through its own links; AIMSIGHT_DATA / AIMSIGHT_LABELS do not follow
turns = [(OPTIMIZER.resolve(), [request, "--plugin-dir", str(AGENTS.resolve()),
"--add-dir", str(DETECTORS.resolve()), # the target of the link, where the session writes
"--allowedTools", "Read,Write,Edit,Bash,Agent"]),
(station.ROOT, [f"Analysis: {rel}/. Tools: tools/. Write {rel}/tools.md.", "--plugin-dir", str(AGENTS),
"--agent", "agents:tool-builder", "--allowedTools", "Read,Write,Edit,Bash"])]
for cwd, (prompt, *options) in turns:
p = subprocess.Popen(["claude", "-p", prompt, *ISOLATED, "--output-format", "stream-json", "--verbose",
"--permission-mode", "acceptEdits", *station.links(), *options],
cwd=cwd, env=_env(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
for line in p.stdout:
stream.write(line)
o["lines"] += digest(line)
if p.wait():
raise RuntimeError(f"claude ended with code {p.returncode}")
o["state"] = "done"
except Exception as e: # noqa: BLE001 — the error shows in the page, the server goes on
o["lines"].append(f"Error: {e}")
o["state"] = "error"
finally:
stream.write(json.dumps({"type": "end", "state": o["state"]}) + "\n")
station.detectors.cache_clear() # the detectors may have changed: the Data page computes them again
def summary(name, dark):
"""The summary of the detectors' session, then that of the tools (<analysis>/tools.md), in one page."""
s, tools = _summary_file(name), FOLDER / name / "tools.md"
if s is None and not tools.exists():
raise station.Refusal("no summary for this analysis")
text = "\n\n".join(f.read_text(encoding="utf-8") for f in (s, tools) if f and f.exists())
return _page(text, name, dark)
+266
View File
@@ -0,0 +1,266 @@
"""Checks of the web app, without calling claude: .venv/bin/python app/server/check.py [name]"""
import json
import os
import shutil
import socket
import sys
import tempfile
import threading
import time
import urllib.request
from pathlib import Path
from urllib.error import HTTPError
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
import uvicorn # noqa: E402
import server # noqa: E402
import station # noqa: E402
def temp_folder():
return Path(tempfile.mkdtemp())
def check_server():
# the real server on a free port: the guard (Host, declared JSON), a read
with socket.socket() as so:
so.bind(("127.0.0.1", 0))
port = so.getsockname()[1]
srv = uvicorn.Server(uvicorn.Config(server.app, host="127.0.0.1", port=port, log_level="error"))
threading.Thread(target=srv.run, daemon=True).start()
while not srv.started:
time.sleep(0.05)
base = f"http://127.0.0.1:{port}"
def call(path, body=None, headers=None, method=None):
r = urllib.request.Request(base + path, json.dumps(body).encode() if body is not None else None,
{"Content-Type": "application/json", **(headers or {})}, method=method)
try:
with urllib.request.urlopen(r) as rep:
return rep.status
except HTTPError as e:
return e.code
try:
assert call("/api/stations", headers={"Host": "evil.example:80"}) == 403
assert call("/api/labels", {"station": "x"}, {"Content-Type": "text/plain"}) == 403
assert call("/api/stations") == 200
assert call("/api/analyses") == 200
assert call("/api/analyses/UNKNOWN/optimize", {}) == 400
finally:
srv.should_exit = True
def refuses(f, *a):
try:
f(*a)
except station.Refusal as e:
return str(e)
raise AssertionError(f"{f.__name__}{a} did not refuse")
def check_station():
# the data of the Data page, on the real data; the labels in a temporary folder
assert "NIEDERHORN" in station.stations()
im = station.images("NIEDERHORN", "2026-09-25", "2026-09-26")
assert im["images"] and im["positions"] and set(im["corr"]) == set(im["positions"]), list(im)
assert all(len(c) == len(im["images"]) for c in im["corr"].values())
assert station.image("NIEDERHORN", im["images"][0]["name"]).is_file()
refuses(station.image, "NIEDERHORN", "../../../.env")
refuses(station.images, "../API", "", "")
assert station.images("LENZSPITZE", "2026-10-26", "2026-10-27")["images"]
c = station.curves("LENZSPITZE", "2026-10-26", "2026-10-27")
titles = [p["title"] for p in c["plots"]]
assert "Relative Corrected Vertical Shift" in titles and any(t.startswith("System: ") for t in titles), titles
ev = station.detectors("LENZSPITZE", "2026-10-26", "2026-10-27") # the detectors of the journal, ~10 s
assert ev and {"start", "end", "family", "description", "sensors"} <= set(ev[0]), ev[:1]
assert all(e["message"] and e["action"] and set(e["targets"] + e["references"]) == set(e["sensors"]) for e in ev), ev[:1]
assert station.message("A moved; nothing to do. The jump of 2 targets in this period has the same cause.") \
== "A moved. The jump of 2 targets in this period has the same cause."
assert all(e["end"] >= "2026-10-26T00:00Z" and e["start"] < "2026-10-27T00:00Z" for e in ev), [(e["start"], e["end"]) for e in ev]
assert not any("SIM_CCID" in t or t.startswith("System: ip") for t in titles)
assert all(len(c["T"][tr["t"]]) == len(tr["y"]) for p in c["plots"] for tr in p["traces"])
before, station.LABELS = station.LABELS, temp_folder()
try:
e = station.add({"station": "NIEDERHORN", "folder": "auto", "start": "2026-09-25T01:00Z",
"end": "2026-09-25T02:00Z", "family": "Visibility", "description": "fog"})
assert e["id"] == "NIEDERHORN-1" and next(iter(e)) == "id", e
e2 = station.update({"station": "NIEDERHORN", "folder": "auto", "before": e,
"start": e["start"], "end": e["end"], "family": "", "description": "rain"})
assert e2 == {"id": "NIEDERHORN-1", "start": e["start"], "end": e["end"], "description": "rain"}, e2
assert station.read("NIEDERHORN", "auto") == [e2]
assert "no longer in the file" in refuses(station.delete, {"station": "NIEDERHORN", "folder": "auto", "before": e})
station.delete({"station": "NIEDERHORN", "folder": "auto", "before": e2})
assert station.read("NIEDERHORN", "auto") == []
refuses(station.add, {"station": "NIEDERHORN", "folder": "../x", "start": "a", "end": "b", "description": "x"})
refuses(station.add, {"station": "NIEDERHORN", "start": "2026-09-25T02:00Z", "end": "2026-09-25T01:00Z", "description": "x"})
finally:
shutil.rmtree(station.LABELS)
station.LABELS = before
def check_optimization():
# the Optimize button (analysis.optimize), without claude: a fake process that ends only on a signal, a finished
# analysis copied into a temporary folder; the lock (one optimization at a time, no analysis or message meanwhile), the
# state read again after a restart
import analysis
end = threading.Event()
launched = []
class FakeProcess:
returncode = 0
stdout = iter(lambda: end.wait() and "", "") # nothing, until the signal
def __init__(self, args, *a, **k):
launched.append((args, k))
def wait(self):
return 0
before = analysis.FOLDER, analysis.subprocess.Popen, analysis.OPTIMIZER, analysis.SESSIONS, analysis.AGENTS
key = os.environ.get("ANTHROPIC_API_KEY")
os.environ["ANTHROPIC_API_KEY"] = "test-key"
root = temp_folder()
analysis.FOLDER, analysis.OPTIMIZER, analysis.AGENTS = root / "analyses", root / "optimizer", root / "agents"
analysis.SESSIONS = analysis.OPTIMIZER / "sessions"
analysis.subprocess.Popen = FakeProcess
try:
for name in ("NORDEND_a", "NORDEND_b"):
(analysis.FOLDER / name / "work").mkdir(parents=True)
(analysis.FOLDER / name / "request.json").write_text(json.dumps(
{"station": "NORDEND", "start": "2026-11-04T21:12Z", "end": "2026-11-07T14:12Z", "hints": ""}))
(analysis.FOLDER / name / "report.md").write_text("# report")
assert analysis.state("NORDEND_a")["optimization"] is None
# without Optimizer, then without agents: a clear refusal, not an error trace
assert "optimizer/" in refuses(analysis.optimize, "NORDEND_a")
(analysis.OPTIMIZER / ".claude" / "skills" / "improve").mkdir(parents=True)
(analysis.OPTIMIZER / ".claude" / "skills" / "improve" / "SKILL.md").write_text("improve")
assert "agents/" in refuses(analysis.optimize, "NORDEND_a")
(analysis.AGENTS / ".claude-plugin").mkdir(parents=True)
(analysis.AGENTS / ".claude-plugin" / "plugin.json").write_text("{}")
assert "optimizer/" in refuses(analysis.optimize, "NORDEND_a") # without the data, labeling, detectors links of Optimizer
for link in ("data", "labeling", "detectors"):
(analysis.OPTIMIZER / link).mkdir()
assert analysis.optimize("NORDEND_a") == {}
assert analysis.state("NORDEND_a")["optimization"]["state"] == "running"
refuses(analysis.optimize, "NORDEND_a")
refuses(analysis.optimize, "NORDEND_b")
refuses(analysis.launch, {"station": "NORDEND", "start": "2026-11-04T00:00Z", "end": "2026-11-05T00:00Z"})
refuses(analysis.message, "NORDEND_b", {"text": "continue"})
end.set()
while analysis.state("NORDEND_a")["optimization"]["state"] == "running":
time.sleep(0.05)
assert analysis.state("NORDEND_a")["optimization"]["state"] == "done"
args, k = launched[0] # /improve in Optimizer, on the range of the analysis, TO excluded
request = args[2]
assert request.startswith("/improve ") and "STATION: data/NORDEND. FROM: 2026-11-04. TO: 2026-11-08." in request \
and "OUT: sessions/NORDEND_a_" in request and "FAMILIES: labeling/families.md." in request \
and "CONTEXT: labeling/auto/analyses/NORDEND_a/report.md." in request, request
assert k["cwd"] == analysis.OPTIMIZER.resolve() and "--plugin-dir" in args, (args, k)
assert all("ANTHROPIC_API_KEY" not in kw["env"] for _, kw in launched), "an API key reaches claude"
# isolated from the settings of the workstation (the user's plugins, hooks, MCP servers)
assert all(a[a.index("--setting-sources") + 1] == "project,local" and "--strict-mcp-config" in a for a, _ in launched)
args, k = launched[1] # then the tool-builder of the agents repository, on the tools repository
assert args[args.index("--agent") + 1] == "agents:tool-builder" and "Tools: tools/" in args[2] \
and args[2].endswith("/tools.md."), args
analysis.analyses["NORDEND_b"]["state"] = "running" # a running analysis blocks the optimization
refuses(analysis.optimize, "NORDEND_a")
# after a restart: the stream ends with {"type": "end"} -> done; without that line -> interrupted; the summary of
# the detectors and that of the tools in one page
stream = analysis.FOLDER / "NORDEND_a" / "work" / "optimization.jsonl"
assert stream.read_text().endswith('{"type": "end", "state": "done"}\n'), stream.read_text()
analysis.analyses.clear()
analysis.optimizations.clear()
assert analysis.state("NORDEND_a")["optimization"]["state"] == "done"
stream.write_text('{"type": "assistant", "message": {"content": []}}\n')
analysis.optimizations.clear()
assert analysis.state("NORDEND_a")["optimization"]["state"] == "interrupted"
(analysis.SESSIONS / "NORDEND_a_20261113T1000Z").mkdir(parents=True)
(analysis.SESSIONS / "NORDEND_a_20261113T1000Z" / "summary.md").write_text("# improve\n\n**Result**: none")
# a new analysis of the same range (NORDEND_a_143000): its session is not the summary of NORDEND_a
(analysis.SESSIONS / "NORDEND_a_143000_20261113T1100Z").mkdir(parents=True)
(analysis.SESSIONS / "NORDEND_a_143000_20261113T1100Z" / "summary.md").write_text("# other analysis")
assert analysis._summary_file("NORDEND_a").parent.name == "NORDEND_a_20261113T1000Z", analysis._summary_file("NORDEND_a")
(analysis.FOLDER / "NORDEND_a" / "tools.md").write_text("# Tools\n\n**Tools changed**: none")
assert analysis.state("NORDEND_a")["optimization"]["summary"]
page = analysis.summary("NORDEND_a", False)
assert "<strong>Result</strong>" in page and "<strong>Tools changed</strong>" in page, page
assert analysis.state("NORDEND_b")["optimization"] is None
finally:
end.set()
os.environ.pop("ANTHROPIC_API_KEY")
if key is not None:
os.environ["ANTHROPIC_API_KEY"] = key
shutil.rmtree(root)
analysis.FOLDER, analysis.subprocess.Popen, analysis.OPTIMIZER, analysis.SESSIONS, analysis.AGENTS = before
analysis.analyses.clear()
analysis.optimizations.clear()
def check_analysis():
# "Analyze the range" then a message (analysis.launch, analysis.message), without claude: the analyst of the agents
# repository, its parameters, and the resumption of its session with the same agent
import analysis
launched = []
class FakeProcess:
returncode = 0
def __init__(self, args, *a, **k):
launched.append((args, k))
self.stdout = iter([])
def wait(self):
return 0
(station.ROOT / "out").mkdir(exist_ok=True) # under the root: the request cites the output folder relative to it
before = analysis.FOLDER, analysis.subprocess.Popen, analysis.submit
analysis.FOLDER = Path(tempfile.mkdtemp(dir=station.ROOT / "out"))
analysis.subprocess.Popen = FakeProcess
analysis.submit = lambda *a: 0 # otherwise the test rewrites the real labeling/auto/NORDEND.jsonl
key = os.environ.get("ANTHROPIC_API_KEY")
os.environ["ANTHROPIC_API_KEY"] = "test-key" # the agent runs on the subscription, never on an API key
try:
name = analysis.launch({"station": "NORDEND", "start": "2026-11-05T06:00Z", "end": "2026-11-05T12:00Z"})["name"]
while analysis.analyses[name]["state"] == "running":
time.sleep(0.05)
assert analysis.analyses[name]["state"] == "done", analysis.analyses[name]
assert json.loads((analysis.FOLDER / name / "request.json").read_text()) == \
{"station": "NORDEND", "start": "2026-11-05T06:00Z", "end": "2026-11-05T12:00Z", "hints": ""}
args, k = launched[0]
assert args[args.index("--agent") + 1] == "agents:analyst" and "--plugin-dir" in args, args
assert "ANTHROPIC_API_KEY" not in k["env"] and "PATH" in k["env"], sorted(k.get("env") or {})
assert args[2].startswith("Station: data/NORDEND/. Range: 2026-11-05T06:00Z → 2026-11-05T12:00Z (UTC). Hints: none. ") \
and "DETECTORS: no" in args[2] and "INSTRUCTIONS: instructions/analyst.md" in args[2], args[2]
assert args[args.index("--setting-sources") + 1] == "project,local" and "--strict-mcp-config" in args, args
(analysis.FOLDER / name / "work" / "session").write_text("s-1")
analysis.message(name, {"text": "continue"})
while analysis.analyses[name]["state"] == "running":
time.sleep(0.05)
args, k = launched[1]
assert "ANTHROPIC_API_KEY" not in k["env"], sorted(k.get("env") or {})
assert args[args.index("--resume") + 1] == "s-1" and args[args.index("--agent") + 1] == "agents:analyst" \
and "--plugin-dir" in args, args
agents, analysis.AGENTS = analysis.AGENTS, analysis.FOLDER / "no-agents" # the agents/ link is missing: clear refusal
try:
assert "agents/" in refuses(analysis.launch, {"station": "NORDEND", "start": "2026-11-06T06:00Z", "end": "2026-11-06T12:00Z"})
finally:
analysis.AGENTS = agents
finally:
os.environ.pop("ANTHROPIC_API_KEY")
if key is not None:
os.environ["ANTHROPIC_API_KEY"] = key
shutil.rmtree(analysis.FOLDER)
analysis.FOLDER, analysis.subprocess.Popen, analysis.submit = before
analysis.analyses.clear()
CHECKS = [check_server, check_station, check_optimization, check_analysis]
if __name__ == "__main__":
name = sys.argv[1] if len(sys.argv) > 1 else None
for f in CHECKS:
if name in (None, f.__name__):
f()
print("ok", f.__name__)
+165
View File
@@ -0,0 +1,165 @@
"""The web app: .venv/bin/python app/server/server.py → http://127.0.0.1:8770
The FastAPI server serves the built React page (app/web/dist, `npm run build` in app/web) and the API under /api.
The Data page reads data/ and the labels of labeling/ (station.py); its Analysis tab launches the analyst, and the
optimization of the detectors (analysis.py).
Settings: AIMSIGHT_DATA (data), AIMSIGHT_LABELS (labels), AIMSIGHT_PORT (port, 8770).
"""
import json
import os
import platform
import subprocess
import sys
import threading
import webbrowser
from pathlib import Path
import uvicorn
from fastapi import FastAPI, Query, Request
from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
import analysis
import station
from fastapi.staticfiles import StaticFiles
APP = Path(__file__).resolve().parents[1]
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
HOSTS = {"127.0.0.1", "localhost"} # against DNS rebinding: another site does not read the data
PAGE = APP / "web" / "dist"
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def error(code: int, text: str) -> JSONResponse:
return JSONResponse({"error": text}, code)
@app.middleware("http")
async def guard(request: Request, call_next):
"""Only the page itself talks to the server: right Host; in POST, a declared JSON (a page of another site cannot send
it without a preflight request, to which the server does not answer)."""
host = request.headers.get("host", "").rsplit(":", 1)[0]
if host not in HOSTS or (request.method in ("POST", "PUT", "DELETE")
and not request.headers.get("content-type", "").startswith("application/json")):
return error(403, "request refused")
return await call_next(request)
# --- the Data page (station.py)
@app.exception_handler(station.Refusal)
def refusal(_, e):
return error(400, str(e))
@app.get("/api/stations")
def stations():
return station.stations()
@app.get("/api/images")
def images(station_: str = Query(alias="station"), start: str = "", end: str = ""):
return station.images(station_, start, end)
@app.get("/api/image/{station_}/{name}")
def image(station_: str, name: str):
return FileResponse(station.image(station_, name), headers={"Cache-Control": "max-age=86400"})
@app.get("/api/curves")
def curves(station_: str = Query(alias="station"), start: str = "", end: str = ""):
return station.curves(station_, start, end)
@app.get("/api/detectors")
def detectors(station_: str = Query(alias="station"), start: str = "", end: str = "", targets: str = ""):
return station.detectors(station_, start, end, targets)
@app.get("/api/labels")
def labels(station_: str = Query(alias="station"), folder: str = "manual"):
try:
return station.read(station_, folder)
except json.JSONDecodeError as e: # a line damaged by hand: say so, without touching the file
return error(500, f"labeling/{folder}/{station_}.jsonl unreadable: {e}")
@app.post("/api/labels")
def add_label(body: dict):
return station.add(body)
@app.put("/api/labels")
def update_label(body: dict):
return station.update(body)
@app.delete("/api/labels")
def delete_label(body: dict):
return station.delete(body)
# --- the Analysis tab of the Data page (analysis.py): the analyst launched by claude -p on a range
@app.post("/api/analyses")
def launch_analysis(body: dict):
return analysis.launch(body)
@app.get("/api/analyses")
def analyses():
return analysis.list_analyses()
@app.get("/api/analyses/{name}")
def analysis_state(name: str):
return analysis.state(name)
@app.post("/api/analyses/{name}/message")
def analysis_message(name: str, body: dict):
return analysis.message(name, body)
@app.get("/api/analyses/{name}/report.html")
def analysis_report(name: str, dark: bool = False):
return HTMLResponse(analysis.report(name, dark))
@app.post("/api/analyses/{name}/optimize")
def optimize_analysis(name: str):
return analysis.optimize(name)
@app.get("/api/analyses/{name}/summary.html")
def analysis_summary(name: str, dark: bool = False):
return HTMLResponse(analysis.summary(name, dark))
@app.get("/api/analyses/{name}/{path:path}")
def analysis_file(name: str, path: str):
return FileResponse(analysis.file(name, path))
if PAGE.is_dir():
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
else:
@app.get("/")
def no_page():
return error(503, "the page is not built: cd app/web && npm install && npm run build")
def open_browser(url: str) -> None:
if "microsoft" in platform.uname().release.lower(): # WSL: the Windows browser
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
else:
webbrowser.open(url)
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
print(f"AIMsight diagnostic: {url}")
if "--no-browser" not in sys.argv:
threading.Timer(1, open_browser, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)
+338
View File
@@ -0,0 +1,338 @@
"""The data of the Data page: a station's images, its curves, its labels.
Data are read as the agents read them, tools/scripts/data.py (the tools repository, through the tools/ link); the detectors'
events are those of detectors/scripts/categories.py (events). Read-only on data/; writes only in labeling/{auto,manual}/.
"""
import bisect
import functools
import csv
import glob
import json
import os
import re
import statistics
import sys
from datetime import datetime, timedelta
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path[:0] = [str(ROOT / "tools" / "scripts"), str(ROOT / "detectors" / "scripts")]
import data # noqa: E402
from categories import events # noqa: E402
# data/ and labeling/ are links to ~/aimsight-data/data and ~/labeling: no resolve(), the agents see data/ and labeling/
DATA = Path(os.environ.get("AIMSIGHT_DATA", ROOT / "data")).absolute()
LABELS = Path(os.environ.get("AIMSIGHT_LABELS", ROOT / "labeling")).absolute()
TOOLS = ROOT / "tools" # the reading harness (~/tools), read by the analyst and written by the tool-builder
def links():
"""--add-dir for claude -p: the real target of the data/, labeling/ and tools/ links, outside the repository."""
return [a for d in (DATA, LABELS, TOOLS) for a in ("--add-dir", str(d.resolve()))]
FOLDERS = ("auto", "manual") # those of the agents and of the page (D-105), those of the expert (D-102)
FAMILIES = ("Visibility", "Obstruction", "Thermal displacement", "Displacement", "Target issue", "No data", "None") # D-109
FORMAT = "%Y-%m-%dT%H:%MZ"
MARGIN_PX = 150 # Support-Agent detecteurs.MARGE_PX: x, y are positions in the image only far from the corner
COLORS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # one per sensor
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d"))
# The Advanced menu of Explore, in its order (Support-Agent labeling.PLOTS, QUALITE)
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
QUALITY = (("peak", "Quality: Peak"), ("flux", "Quality: Flux"), ("sharpness", "Quality: Sharpness"),
("fwhm", "Quality: FWHM [px]"), ("dominance", "Quality: Dominance"), ("snr", "Quality: SNR"))
IDENTIFIER = re.compile(r"(SIM_CCID|ip(_.*)?)$") # never read (CLAUDE.md, "data/")
METRIC = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
class Refusal(ValueError):
"""A request to refuse (400), with its reason."""
def stations():
return sorted(d.name for d in DATA.iterdir() if d.is_dir())
def folder(station):
if station not in stations(): # the name becomes a path: a folder of data/, nothing else
raise Refusal(f"unknown station: {station}")
return DATA / station
def bounds(start, end):
return data.parse_time(start or "0001-01-01"), data.parse_time(end or "9999-01-01")
# --- the positions of the sensors in the image
def positions(measurements, a, b):
"""The median position of each sensor in the image over [a, b) ({} if x, y are not positions there)."""
homes = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in measurements.items()
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
return homes if any(abs(x) > MARGIN_PX or abs(y) > MARGIN_PX for x, y in homes.values()) else {}
def references(measurements, a, b):
"""Sensors of the compensation over the range: those with a reproj_err (references only)."""
return {s for s, ms in measurements.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)}
# --- the images of the Data page
def images(station, start, end):
"""The images of [start, end), the median positions of the sensors, the references, and for each circled sensor its
corr_x, corr_y at the time of each image: the nearest valid measurement, within 30 min, otherwise 0."""
d, (a, b) = folder(station), bounds(start, end)
views = [(t, im) for im in sorted(glob.glob(str(d / "images" / "*"))) if (t := data.image_time(im)) and a <= t < b]
if not views:
raise Refusal(f"no image of {station} in this range")
measurements = data.load(d)
homes, refs = positions(measurements, a, b), references(measurements, a, b)
# ponytail: a single measurement at each bound, noisy; a median over a window if the arrows shake too much
margin, corr = timedelta(minutes=30), {}
for s in homes:
series = [(m["t"], m["corr_x"], m["corr_y"]) for m in measurements[s] if m["corr_x"] is not None and m["corr_y"] is not None]
times, corr[s] = [m[0] for m in series], []
for t, _ in views:
k = bisect.bisect_left(times, t)
k = min((n for n in (k - 1, k) if 0 <= n < len(series)), key=lambda n: abs(times[n] - t), default=None)
corr[s].append([round(series[k][1], 4), round(series[k][2], 4)] if k is not None and abs(times[k] - t) <= margin else 0)
return {"images": [{"t": data.iso(t).replace("T", " ").rstrip("Z"), "name": os.path.basename(im)} for t, im in views],
"positions": {s: [round(x, 1), round(y, 1)] for s, (x, y) in sorted(homes.items())},
"references": sorted(refs), "corr": corr}
def image(station, name):
f = (folder(station) / "images" / name).resolve()
if f.parent != (DATA / station / "images").resolve() or not f.is_file():
raise Refusal("unknown image")
return f
# --- the curves of the Data page
def metrics(d, a, b):
"""The numeric system metrics of metrics/ over [a, b) -> {name: {t: value or None}} (an empty value: None, the gap
shows), without the text metrics, the identifiers, or those with no value at all."""
station, series, text = d.name + "_", {}, set()
for p in sorted(glob.glob(str(d / "metrics" / "*.csv"))):
if not (m := METRIC.match(os.path.basename(p))) or IDENTIFIER.match(name := m.group(1).removeprefix(station)):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
t, v = data.parse_time(r["time_utc"]), (r.get("metric") or "").strip("[]'\" ")
if not a <= t < b:
continue
try:
series.setdefault(name, {})[t] = float(v) if v else None
except ValueError:
text.add(name) # link, mode…: no curve
return {n: dict(sorted(s.items())) for n, s in series.items()
if n not in text and any(v is not None for v in s.values())}
def span(measurements, start, end):
"""The range read: from start to end (excluded), otherwise from the first measurement to the last, plus one step."""
every = sorted({m["t"] for ms in measurements.values() for m in ms})
a = data.parse_time(start) if start else every[0]
b = data.parse_time(end) if end else every[-1] + (every[-1] - every[-2] if len(every) > 1 else timedelta(hours=1))
return a, b
def curves(station, start, end):
"""-> {A, B, T, plots}: T, the times of each series, once (key: the sensor, "" for the camera, "system:" and its
name for a metric); plot: title and traces (name, t, y, line, mode), without empty plots or sensors."""
d = folder(station)
measurements = data.load(d)
if not measurements:
raise Refusal(f"no \"advanced\" export for {station}")
a, b = span(measurements, start, end)
poses = [p for p in data.load_camera(d) if a <= p["t"] < b]
hour = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, without time zone: as Plotly shows it)
values = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
inside = {s: [m for m in measurements[s] if a <= m["t"] < b] for s in sorted(measurements)}
refs, out = references(measurements, a, b), []
def per_sensor(columns):
for col, title in columns:
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": COLORS[i % len(COLORS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate((s, values(ms, col)) for s, ms in inside.items()) if any(v is not None for v in y)]
if traces:
out.append({"title": title, "traces": traces})
per_sensor(PLOTS)
if poses:
out.append({"title": "Camera movement (deg)", "traces": [{"name": c, "t": "", "y": values(poses, c),
"line": {"width": 1.2, "color": col}} for c, col in POSE]})
per_sensor(QUALITY)
T = {"": [hour(p["t"]) for p in poses], **{s: [hour(m["t"]) for m in ms] for s, ms in inside.items()}}
system = metrics(d, a, b)
for name in sorted(system, key=str.lower):
T["system:" + name] = [hour(t) for t in system[name]]
out.append({"title": "System: " + name, "traces": [{"name": name, "t": "system:" + name, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in system[name].values()],
"line": {"width": 1.2, "color": COLORS[0]}}]})
if not out:
raise Refusal(f"no measurement of {station} in this range")
return {"A": data.iso(a), "B": data.iso(b), "T": T, "plots": out}
# --- the Data page, "Detectors" labels: the events of the journal, read-only
HISTORY = timedelta(days=3) # days before given to the detectors, as categories.py does (rule of 2026-10-24)
# ponytail: kept until the server restarts (a minute or more per range); restart it after an /improve run outside the app
@functools.lru_cache(maxsize=32)
def detectors(station, start, end, targets=""):
"""-> the detectors' events over the range, in the label format (start, end, family, description); plus kind,
sensors, ignore (greyed area of the journal). targets: the sensors kept, comma-separated (empty: all); the others are
removed before the detectors, as if they did not exist."""
d = folder(station)
every = data.load(d)
if targets:
keep = set(targets.split(","))
every = {s: ms for s, ms in every.items() if s in keep}
if not every:
raise Refusal(f"no \"advanced\" export for {station}" + " with these targets" * bool(targets))
a, b = span(every, start, end)
measurements = {s: k for s, ms in every.items() if (k := [m for m in ms if a - HISTORY <= m["t"] < b])}
evs = [v for v in events(measurements, b, str(d)) if v["end"] >= data.iso(a)] if measurements else []
refs = {s for s, ms in measurements.items() if ms[0]["pattern_type"] == "global_ref"}
return [{"id": f"D-{i + 1}", "start": v["start"], "end": v["end"], "family": v["category"], "kind": v["episodes"][0]["label"],
"description": f"{v['episodes'][0]['label']}. {v['text']}", "sensors": v["sensors"], "ignore": v["ignore"],
"targets": [s for s in v["sensors"] if s not in refs], "references": [s for s in v["sensors"] if s in refs],
"message": message(v["text"]), "action": action(v)}
for i, v in enumerate(evs)]
def message(text):
"""What happens: the first sentence of the journal (detectors/scripts/categories.py, sentence), up to its ";"; the rest
says what to do about it, except the sentence of the absorbed jumps, kept. ". " only: "1.5×" or "0.30 px" do not cut."""
same = re.search(r" (The jumps? of .* same cause\.)$", text)
return re.split(r"\. |; ", text, maxsplit=1)[0].rstrip(".") + "." + (" " + same.group(1) if same else "")
# What to do about it: the "For the client" column of labeling/families.md, per family; refined per kind (the label of the
# main episode, with its level) after the journal sentences validated on 2026-10-24 (detectors/scripts/categories.py, sentence)
ACTION_FAMILY = {
"Visibility": "Do not trust the curves in this period: this is not a movement.",
"Obstruction": "Ignore the curves of the hidden targets in this period.",
"Thermal displacement": "Normal, nothing to do.",
"Displacement": "To check: look at the images, then keep watching.",
"Target issue": "Act on the target (prism, mount); ignore its curve in the meantime.",
"No data": "The curves are missing in this period; its cause tells whether to act.",
}
ACTION_KIND = {
"Poor visibility reduced": "Use the data in this period with care: they are less precise.",
"Heat shimmer": "Nothing to do: the small fast wiggles are not movement.",
"Camera thermal movement": "Nothing to do: this is not a movement of the structure.",
"Brief obstruction": "Ignore this single point on the curves.",
"Sudden jump, back to normal": "Look at the images: the cause is not established.",
"Lasting shift": "Check whether the structure moved: look at the images.",
"Jump, not back yet": "Check whether the structure moved: look at the images.",
"Large shift": "Check whether the structure moved: look at the images.",
"Slow drift": "Keep watching it.",
}
def action(v):
ep = v["episodes"][0]
return ACTION_KIND.get(f"{ep['label']} {ep.get('level') or ''}".strip(), ACTION_KIND.get(ep["label"])) \
or ACTION_FAMILY.get(v["category"], "")
# --- the labels
def label_file(station, source):
if source not in FOLDERS:
raise Refusal("unknown label folder")
folder(station)
return LABELS / source / f"{station}.jsonl"
def read(station, source):
f = label_file(station, source)
# split and not splitlines: the latter would also cut on the Unicode separators the text may contain
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
def assign_ids(station, labels):
"""As labeling/ids.py does (D-131): an id for the labels without one, the next of the station, as first field."""
n = max((int(e["id"].rsplit("-", 1)[1]) for e in labels if "id" in e), default=0)
for e in labels:
if "id" not in e:
n += 1
e["id"] = f"{station}-{n}"
if next(iter(e)) != "id":
rest = {k: v for k, v in e.items() if k != "id"}
ident = e["id"]
e.clear()
e.update({"id": ident}, **rest)
def _validate(body, start, end):
description = (body.get("description") or "").strip()
try:
empty = datetime.strptime(start, FORMAT) >= datetime.strptime(end, FORMAT)
except (TypeError, ValueError):
raise Refusal("unreadable bounds (YYYY-MM-DDTHH:MMZ)") from None
if not description or empty:
raise Refusal("empty text or empty range")
family = body.get("family") or ""
if family and family not in FAMILIES:
raise Refusal("unknown family")
return description, family
def add(body):
station, source = body.get("station"), body.get("folder", "manual")
f = label_file(station, source)
description, family = _validate(body, body.get("start"), body.get("end"))
label = {"start": body["start"], "end": body["end"]} | ({"family": family} if family else {}) | {"description": description}
if source == "auto": # an automatic label carries a stable id, the next of its station (D-131)
assign_ids(station, read(station, "auto") + [label])
f.parent.mkdir(parents=True, exist_ok=True)
before = f.read_bytes() if f.exists() else b"" # a line removed by hand may leave the file without a final newline
with open(f, "ab") as out:
out.write(b"\n" * bool(before and not before.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
def update(body):
before = body.get("before") or {}
start, end = body.get("start", before.get("start")), body.get("end", before.get("end"))
description, family = _validate(body, start, end)
label = dict.fromkeys(("id", "start", "end", "family")) | before | {"start": start, "end": end, "family": family,
"description": description}
if label["id"] is None:
del label["id"]
if not family:
del label["family"]
label.pop("review", None) # changed: no longer reviewed
return replace(body.get("station"), body.get("folder", "manual"), before, label)
def delete(body):
replace(body.get("station"), body.get("folder", "manual"), body.get("before"), None)
return body.get("before")
def replace(station, source, before, label):
"""Replaces the label before by label (None: removes it), found by its content, not by its rank: the file may have
changed since the page was loaded. Writes next to it then replaces: an interruption does not damage the file."""
f = label_file(station, source)
lines = f.read_text(encoding="utf-8").split("\n") if f.exists() else []
for i, line in enumerate(lines):
if line.strip() and json.loads(line) == before:
lines[i:i + 1] = [] if label is None else [json.dumps(label, ensure_ascii=False)]
temp = f.with_name(f.name + ".tmp")
temp.write_text("\n".join(lines), encoding="utf-8")
os.replace(temp, f)
return label
raise Refusal("this label is no longer in the file: reload the page")
-300
View File
@@ -1,300 +0,0 @@
"""L'onglet Analysis de la page Data : l'analyste (.claude/agents/analyste.md) lancé par `claude -p`, non interactif, sur une
plage choisie dans la page, avec les indices facultatifs de l'utilisateur. Il écrit dans
labeling/auto/analyses/<STATION>_<début>_<fin>/ ses étiquettes (etiquettes.jsonl) et un rapport de diagnostic (rapport.md, ses
figures à côté) ; à la fin, le serveur verse ses étiquettes dans labeling/auto/<STATION>.jsonl, marquées de leur analyse
(champ `analyse`). Puis l'utilisateur peut lui écrire : la même session reprend (`claude -p --resume`), et ses étiquettes, si
elles changent, remplacent celles qu'il avait versées.
Sur une analyse finie, « Optimiser » lance `/detectors:wf-improve` (le plugin du dépôt detectors, monté en detectors/) sur
la plage de l'analyse, ses étiquettes pour vérité, qui améliore les détecteurs, puis le tool-builder (.claude/agents/tool-builder.md), qui fait entrer
les scripts de l'analyste dans les outils de lecture ; une optimisation à la fois, ni analyse ni message pendant ; le bilan de
la séance (<analyse>/detectors/<heure>/summary.md) et celui des outils (<analyse>/outils.md) s'affichent sous
le rapport.
"""
import html
import json
import os
import subprocess
import threading
from datetime import date, datetime, timedelta, timezone
import markdown
import station
DOSSIER = station.ETIQUETTES / "auto" / "analyses"
DETECTEURS = station.RACINE / "detectors"
# la requête de /detectors:wf-improve (detectors/README.md) : tout ce qu'il lit et écrit est donné ici, avec ses règles git
AMELIORER = """/detectors:wf-improve DETECTORS: detectors/. STATION: {donnees}/{station}. FROM: {du}. TO: {au}. \
LABELS: {etiquettes}/auto/{station}.jsonl. REFERENCE: --labels {etiquettes}/auto --data {donnees}. \
FAMILIES: {etiquettes}/familles.md. CONTEXT: {analyse}/rapport.md. OUT: {sortie}/. Caller's context: Diagnostic-app, \
the detectors/ submodule; read-only on {donnees}/ and {etiquettes}/; commit only in detectors/, on its current branch; \
OUT is in the labeling repository (labeling/ is a link to it): do not commit it."""
DEMANDE = """Station : data/{station}/. Plage : {debut} → {fin} (UTC). Indices de l'utilisateur : {indices}. \
Dossier de sortie : {sortie}/."""
# nom -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...], "versees": n} ; une analyse à la fois par plage
analyses, verrou = {}, threading.Lock()
# nom de l'analyse -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...]} ; une optimisation à la fois, toutes analyses
optimisations = {}
OCCUPE = "une optimisation des détecteurs est en cours"
def _optimise():
return any(o["etat"] == "en cours" for o in optimisations.values())
def lancer(corps):
st, debut, fin = corps.get("station"), corps.get("debut"), corps.get("fin")
station._valide({"description": "-"}, debut, fin)
station.dossier(st)
nom = f"{st}_{debut[:16].replace(':', '')}_{fin[:16].replace(':', '')}"
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if analyses.get(nom, {}).get("etat") == "en cours":
raise station.Refus("cette plage est déjà en cours d'analyse")
sortie = DOSSIER / nom
if sortie.exists(): # une nouvelle analyse de la même plage : l'ancienne reste, à côté
nom += datetime.now(timezone.utc).strftime("_%H%M%S")
sortie = DOSSIER / nom
indices = (corps.get("indices") or "").strip()
demande = {"station": st, "debut": debut, "fin": fin, "indices": indices}
analyses[nom] = {"etat": "en cours", "lignes": [], "versees": 0, "station": st, "demande": demande}
(sortie / "travail").mkdir(parents=True)
(sortie / "demande.json").write_text(json.dumps(demande, ensure_ascii=False, indent=1), encoding="utf-8")
prompt = DEMANDE.format(station=st, debut=debut, fin=fin, sortie=sortie.relative_to(station.RACINE),
indices=indices or "aucun")
threading.Thread(target=travailler, args=(nom, sortie, prompt), daemon=True).start()
return {"nom": nom}
def travailler(nom, sortie, prompt, reprise=None):
"""Un tour de l'analyste : la demande, ou un message de l'utilisateur dans la même session (reprise : son id)."""
a = analyses[nom]
try:
p = subprocess.Popen(["claude", "-p", prompt, "--agent", "analyste", "--output-format", "stream-json", "--verbose",
"--allowedTools", "Read,Write,Bash", "--permission-mode", "acceptEdits", *station.liens()]
+ (["--resume", reprise] if reprise else []),
cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal:
for ligne in p.stdout:
journal.write(ligne)
a["lignes"] += resume(ligne)
if '"subtype":"init"' in ligne: # la session, pour les messages suivants
(sortie / "travail" / "session").write_text(json.loads(ligne)["session_id"])
if p.wait():
raise RuntimeError(f"claude a fini avec le code {p.returncode}")
a["versees"] = verser(a["station"], nom, sortie)
a["etat"] = "fini"
except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue
a["lignes"].append(f"Erreur : {e}")
a["etat"] = "erreur"
def message(nom, corps):
"""Un message de l'utilisateur à l'analyste, après son rapport : la même session reprend (claude -p --resume)."""
texte, sortie = (corps.get("texte") or "").strip(), DOSSIER / nom
etat(nom) # le nom vérifié, l'état relu après un redémarrage
a, session = analyses[nom], sortie / "travail" / "session"
if not texte or not session.exists():
raise station.Refus("message vide, ou l'analyse n'a pas de session à reprendre")
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if a["etat"] == "en cours":
raise station.Refus("l'analyste travaille encore")
a["etat"] = "en cours"
ligne = json.dumps({"type": "page", "texte": texte}, ensure_ascii=False) + "\n"
with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal:
journal.write(ligne)
a["lignes"] += resume(ligne)
prompt = (f"{texte}\n\n(Si tu changes tes étiquettes, réécris {sortie.relative_to(station.RACINE)}/etiquettes.jsonl en "
"entier, le serveur les reversera ; si le diagnostic change, mets rapport.md à jour.)")
threading.Thread(target=travailler, args=(nom, sortie, prompt, session.read_text()), daemon=True).start()
return {}
def resume(ligne):
"""Une ligne du journal -> ce que la page en montre : les messages de l'utilisateur (« › »), les textes de l'analyste, ses
outils et leur commande, en une ligne chacun."""
try:
m = json.loads(ligne)
except json.JSONDecodeError:
return [ligne.strip()[:200]] if ligne.strip() else []
if m.get("type") == "page":
return [f"› {m['texte']}"]
if m.get("type") != "assistant":
return []
out = []
for c in m["message"].get("content", []):
if c.get("type") == "text" and c["text"].strip():
out.append(c["text"].strip()[:300])
elif c.get("type") == "tool_use":
i = c.get("input", {})
out.append(f"{c['name']} : {i.get('command') or i.get('file_path') or ''}"[:200])
return out
def verser(st, nom, sortie):
"""Les étiquettes de l'analyse dans labeling/auto/<STATION>.jsonl, avec leur id et le nom de l'analyse ; si l'analyste les
a changées depuis le dernier versement, elles remplacent celles qu'il y avait versées -> leur nombre."""
fichier, copie = sortie / "etiquettes.jsonl", sortie / "travail" / "versees.jsonl"
texte = fichier.read_text(encoding="utf-8") if fichier.exists() else ""
nouvelles = []
for l in texte.split("\n"):
if l.strip():
e = json.loads(l)
station._valide(e, e.get("debut"), e.get("fin"))
nouvelles.append({k: e[k] for k in ("debut", "fin", "categorie", "description") if k in e} | {"analyse": nom})
if copie.exists() and copie.read_text(encoding="utf-8") == texte:
return len(nouvelles)
# ponytail: retirées puis remises, les étiquettes de l'analyse perdent les retouches faites dans la page ; les garder
# demanderait de les apparier une à une
with verrou:
f = station.fichier(st, "auto") # les autres lignes restent telles quelles
gardees = [l for l in (f.read_text(encoding="utf-8").split("\n") if f.exists() else [])
if l.strip() and json.loads(l).get("analyse") != nom]
station.attribuer(st, [json.loads(l) for l in gardees] + nouvelles)
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("".join(l + "\n" for l in gardees + [json.dumps(e, ensure_ascii=False) for e in nouvelles]),
encoding="utf-8")
os.replace(provisoire, f)
copie.write_text(texte, encoding="utf-8")
return len(nouvelles)
def etat(nom):
sortie = DOSSIER / nom
if "/" in nom or nom.startswith(".") or not sortie.is_dir():
raise station.Refus("analyse inconnue")
if nom not in analyses: # après un redémarrage du serveur, il ne reste que le dossier : le fil se relit dans le journal
journal = sortie / "travail" / "journal.jsonl"
lignes = [r for l in open(journal, encoding="utf-8") for r in resume(l)] if journal.exists() else []
demande = json.loads((sortie / "demande.json").read_text(encoding="utf-8"))
analyses[nom] = {"etat": "fini" if (sortie / "rapport.md").exists() else "interrompue", "lignes": lignes,
"versees": None, "station": demande["station"], "demande": demande}
a, r = analyses[nom], sortie / "rapport.md"
return {"nom": nom, "etat": a["etat"], "lignes": a["lignes"], "versees": a["versees"],
"rapport": int(r.stat().st_mtime) if r.exists() else None,
"dialogue": (sortie / "travail" / "session").exists(), "demande": a["demande"], "optimisation": optimisation(nom)}
def liste():
"""L'historique des analyses (la barre latérale), la plus récente en tête : celles du serveur avec leur état, les autres
lues sur le disque (fini avec un rapport, sinon interrompue : une analyse s'arrête avec le serveur)."""
out = []
for d in sorted(DOSSIER.glob("*/demande.json"), key=lambda f: f.parent.stat().st_mtime, reverse=True):
nom = d.parent.name
a = analyses.get(nom) or {"etat": "fini" if (d.parent / "rapport.md").exists() else "interrompue",
"demande": json.loads(d.read_text(encoding="utf-8"))}
out.append({"nom": nom, "etat": a["etat"]} | a["demande"])
return out
def fichier(nom, chemin):
"""Un fichier du dossier de l'analyse (le rapport, ses figures), jamais au-dehors."""
f = (DOSSIER / nom / chemin).resolve()
if not f.is_file() or not f.is_relative_to(DOSSIER.resolve()):
raise station.Refus("fichier inconnu")
return f
STYLE = """body{font:14px/1.55 Roboto,sans-serif;margin:0;padding:4px 2px;color:#212529;background:transparent}
h1{font-size:20px}h2{font-size:16px;margin-top:22px}img{max-width:100%;border:1px solid #dee2e6;border-radius:4px}
code{font-size:12px;background:#f1f3f5;padding:1px 4px;border-radius:3px}pre{overflow-x:auto}
table{border-collapse:collapse}td,th{border:1px solid #dee2e6;padding:3px 8px;text-align:left}
body.sombre{color:#c9c9c9}body.sombre code{background:#2e2e2e}body.sombre td,body.sombre th,body.sombre img{border-color:#424242}"""
def _page(texte, titre, sombre):
"""Un markdown en HTML, au style de la page ; ses images relatives se résolvent dans le dossier de l'adresse."""
corps = markdown.markdown(texte, extensions=["tables", "fenced_code"])
return (f"<!doctype html><meta charset=utf-8><title>{html.escape(titre)}</title><style>{STYLE}</style>"
f"<body class='{'sombre' if sombre else ''}'>{corps}</body>")
def rapport(nom, sombre):
"""rapport.md en HTML, servi dans le dossier de l'analyse : ses images relatives s'y retrouvent."""
return _page(fichier(nom, "rapport.md").read_text(encoding="utf-8"), nom, sombre)
# --- « Optimiser » : /detectors:wf-improve sur l'analyse, puis le tool-builder, par claude -p
def _bilan(nom):
"""Le bilan de la dernière séance de cette analyse, ou None."""
bilans = sorted((DOSSIER / nom / "detectors").glob("*/summary.md")) # <heure>/ : l'ordre du nom est celui du temps
return bilans[-1] if bilans else None
def optimisation(nom):
"""-> None (jamais optimisée) ou {etat, lignes, bilan : mtime du dernier bilan}. Après un redémarrage, l'état se relit dans
le flux : sa dernière ligne {"type": "fin"} dit fini ou erreur ; sans elle, l'optimisation a été coupée (interrompue)."""
flux, b = DOSSIER / nom / "travail" / "optimisation.jsonl", _bilan(nom)
o = optimisations.get(nom)
if o is None:
if not flux.exists():
return None
lignes = flux.read_text(encoding="utf-8").splitlines()
fin = json.loads(lignes[-1]) if lignes and lignes[-1].startswith('{"type": "fin"') else None
o = {"etat": "interrompue" if fin is None else fin["etat"], "lignes": [r for l in lignes for r in resume(l)]}
optimisations[nom] = o
return {"etat": o["etat"], "lignes": o["lignes"], "bilan": int(b.stat().st_mtime) if b else None}
def optimiser(nom):
"""Le bouton « Optimiser » sur une analyse finie : la séance dans un fil ; refusée si une optimisation ou une analyse tourne."""
if etat(nom)["etat"] != "fini":
raise station.Refus("seule une analyse finie s'optimise")
if not (DETECTEURS / ".claude-plugin" / "plugin.json").exists():
raise station.Refus("le dépôt detectors n'est pas monté en detectors/ (git submodule update --init)")
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if any(a["etat"] == "en cours" for a in analyses.values()):
raise station.Refus("une analyse est en cours : l'optimisation attend sa fin")
optimisations[nom] = {"etat": "en cours", "lignes": []}
threading.Thread(target=optimiser_fil, args=(nom,), daemon=True).start()
return {}
def optimiser_fil(nom):
"""Les deux tours de l'optimisation, l'un après l'autre : les détecteurs (le plugin detectors), puis les outils de lecture
(le tool-builder, même si les détecteurs n'ont pas changé)."""
o, sortie = optimisations[nom], DOSSIER / nom
rel = os.path.relpath(sortie, station.RACINE)
(sortie / "travail").mkdir(exist_ok=True)
with open(sortie / "travail" / "optimisation.jsonl", "a", encoding="utf-8") as flux:
try:
d = json.loads((sortie / "demande.json").read_text(encoding="utf-8"))
requete = AMELIORER.format( # TO exclu : le jour après la fin de la plage, comme la page
station=d["station"], du=d["debut"][:10], au=date.fromisoformat(d["fin"][:10]) + timedelta(days=1),
donnees=os.path.relpath(station.DONNEES, station.RACINE), etiquettes=os.path.relpath(station.ETIQUETTES, station.RACINE),
analyse=rel, sortie=f"{rel}/detectors/{datetime.now(timezone.utc):%Y%m%dT%H%MZ}")
tours = [[requete, "--plugin-dir", "detectors",
"--allowedTools", "Read,Write,Edit,Bash,Agent"],
[f"Analyse : {rel}/. Écris {rel}/outils.md.", "--agent", "tool-builder", "--allowedTools", "Read,Write,Edit,Bash"]]
for prompt, *options in tours:
p = subprocess.Popen(["claude", "-p", prompt, "--output-format", "stream-json", "--verbose",
"--permission-mode", "acceptEdits", *station.liens(), *options],
cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
for ligne in p.stdout:
flux.write(ligne)
o["lignes"] += resume(ligne)
if p.wait():
raise RuntimeError(f"claude a fini avec le code {p.returncode}")
o["etat"] = "fini"
except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue
o["lignes"].append(f"Erreur : {e}")
o["etat"] = "erreur"
finally:
flux.write(json.dumps({"type": "fin", "etat": o["etat"]}) + "\n")
station.detecteurs.cache_clear() # les détecteurs ont pu changer : la page Data les recalcule
def bilan(nom, sombre):
"""Le bilan de la séance des détecteurs, puis celui des outils (<analyse>/outils.md), en une page."""
b, outils = _bilan(nom), DOSSIER / nom / "outils.md"
if b is None and not outils.exists():
raise station.Refus("aucun bilan pour cette analyse")
texte = "\n\n".join(f.read_text(encoding="utf-8") for f in (b, outils) if f and f.exists())
return _page(texte, nom, sombre)
-177
View File
@@ -1,177 +0,0 @@
"""Vérifications de la web app, sans appel à claude : .venv/bin/python app/serveur/check.py [nom]"""
import json
import shutil
import socket
import sys
import tempfile
import threading
import time
import urllib.request
from pathlib import Path
from urllib.error import HTTPError
ICI = Path(__file__).resolve().parent
sys.path.insert(0, str(ICI))
import uvicorn # noqa: E402
import serveur # noqa: E402
import station # noqa: E402
def seance_temporaire():
return Path(tempfile.mkdtemp())
def check_serveur():
# le vrai serveur sur un port libre : la garde (Host, JSON déclaré), une lecture
with socket.socket() as so:
so.bind(("127.0.0.1", 0))
port = so.getsockname()[1]
srv = uvicorn.Server(uvicorn.Config(serveur.app, host="127.0.0.1", port=port, log_level="error"))
threading.Thread(target=srv.run, daemon=True).start()
while not srv.started:
time.sleep(0.05)
base = f"http://127.0.0.1:{port}"
def appel(chemin, corps=None, entetes=None, methode=None):
r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None,
{"Content-Type": "application/json", **(entetes or {})}, method=methode)
try:
with urllib.request.urlopen(r) as rep:
return rep.status
except HTTPError as e:
return e.code
try:
assert appel("/api/stations", entetes={"Host": "evil.example:80"}) == 403
assert appel("/api/etiquettes", {"station": "x"}, {"Content-Type": "text/plain"}) == 403
assert appel("/api/stations") == 200
assert appel("/api/analyses") == 200
assert appel("/api/analyses/INCONNUE/optimiser", {}) == 400
finally:
srv.should_exit = True
def leve(f, *a):
try:
f(*a)
except station.Refus as e:
return str(e)
raise AssertionError(f"{f.__name__}{a} n'a pas refusé")
def check_station():
# les données de la page Data, sur les vraies données ; les étiquettes dans un dossier temporaire
assert "NIEDERHORN" in station.stations()
im = station.images("NIEDERHORN", "2026-09-25", "2026-09-26")
assert im["images"] and im["positions"] and set(im["corr"]) == set(im["positions"]), list(im)
assert all(len(c) == len(im["images"]) for c in im["corr"].values())
assert station.image("NIEDERHORN", im["images"][0]["nom"]).is_file()
leve(station.image, "NIEDERHORN", "../../../.env")
leve(station.images, "../API", "", "")
assert station.images("LENZSPITZE", "2026-10-26", "2026-10-27")["images"]
c = station.courbes("LENZSPITZE", "2026-10-26", "2026-10-27")
titres = [p["titre"] for p in c["plots"]]
assert "Relative Corrected Vertical Shift" in titres and any(t.startswith("System: ") for t in titres), titres
ev = station.detecteurs("LENZSPITZE", "2026-10-26", "2026-10-27") # les détecteurs du journal, ~10 s
assert ev and {"debut", "fin", "categorie", "description", "capteurs"} <= set(ev[0]), ev[:1]
assert all(e["message"] and e["action"] and set(e["cibles"] + e["references"]) == set(e["capteurs"]) for e in ev), ev[:1]
assert station.message("A moved; nothing to do. The jump of 2 targets in this period has the same cause.") \
== "A moved. The jump of 2 targets in this period has the same cause."
assert all(e["fin"] >= "2026-10-26T00:00Z" and e["debut"] < "2026-10-27T00:00Z" for e in ev), [(e["debut"], e["fin"]) for e in ev]
assert not any("SIM_CCID" in t or t.startswith("System: ip") for t in titres)
assert all(len(c["T"][tr["t"]]) == len(tr["y"]) for p in c["plots"] for tr in p["traces"])
avant, station.ETIQUETTES = station.ETIQUETTES, seance_temporaire()
try:
e = station.ajouter({"station": "NIEDERHORN", "dossier": "auto", "debut": "2026-09-25T01:00Z",
"fin": "2026-09-25T02:00Z", "categorie": "Visibility", "description": "brouillard"})
assert e["id"] == "NIEDERHORN-1" and next(iter(e)) == "id", e
e2 = station.modifier({"station": "NIEDERHORN", "dossier": "auto", "avant": e,
"debut": e["debut"], "fin": e["fin"], "categorie": "", "description": "pluie"})
assert e2 == {"id": "NIEDERHORN-1", "debut": e["debut"], "fin": e["fin"], "description": "pluie"}, e2
assert station.lire("NIEDERHORN", "auto") == [e2]
assert "plus dans le fichier" in leve(station.supprimer, {"station": "NIEDERHORN", "dossier": "auto", "avant": e})
station.supprimer({"station": "NIEDERHORN", "dossier": "auto", "avant": e2})
assert station.lire("NIEDERHORN", "auto") == []
leve(station.ajouter, {"station": "NIEDERHORN", "dossier": "../x", "debut": "a", "fin": "b", "description": "x"})
leve(station.ajouter, {"station": "NIEDERHORN", "debut": "2026-09-25T02:00Z", "fin": "2026-09-25T01:00Z", "description": "x"})
finally:
shutil.rmtree(station.ETIQUETTES)
station.ETIQUETTES = avant
def check_optimisation():
# le bouton Optimiser (analyse.optimiser), sans claude : un faux processus qui ne finit que sur signal, une analyse finie
# copiée dans un dossier temporaire ; le verrou (une optimisation à la fois, ni analyse ni message pendant), l'état
# relu après un redémarrage
import analyse
fin = threading.Event()
lances = []
class FauxProcessus:
returncode = 0
stdout = iter(lambda: fin.wait() and "", "") # rien, jusqu'au signal
def __init__(self, args, *a, **k):
lances.append(args)
def wait(self):
return 0
avant = analyse.DOSSIER, analyse.subprocess.Popen
analyse.DOSSIER = seance_temporaire()
analyse.subprocess.Popen = FauxProcessus
try:
for nom in ("NORDEND_a", "NORDEND_b"):
(analyse.DOSSIER / nom / "travail").mkdir(parents=True)
(analyse.DOSSIER / nom / "demande.json").write_text(json.dumps(
{"station": "NORDEND", "debut": "2026-11-04T21:12Z", "fin": "2026-11-07T14:12Z", "indices": ""}))
(analyse.DOSSIER / nom / "rapport.md").write_text("# rapport")
assert analyse.etat("NORDEND_a")["optimisation"] is None
assert analyse.optimiser("NORDEND_a") == {}
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours"
leve(analyse.optimiser, "NORDEND_a")
leve(analyse.optimiser, "NORDEND_b")
leve(analyse.lancer, {"station": "NORDEND", "debut": "2026-11-04T00:00Z", "fin": "2026-11-05T00:00Z"})
leve(analyse.message, "NORDEND_b", {"texte": "continue"})
fin.set()
while analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours":
time.sleep(0.05)
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "fini"
requete = lances[0][2] # la plage de l'analyse, TO exclu
assert requete.startswith("/detectors:wf-improve ") and "/NORDEND. FROM: 2026-11-04. TO: 2026-11-08. LABELS: " \
in requete and "/NORDEND_a/detectors/" in requete, requete
analyse.analyses["NORDEND_b"]["etat"] = "en cours" # une analyse qui tourne bloque l'optimisation
leve(analyse.optimiser, "NORDEND_a")
# après un redémarrage : le flux finit par {"type": "fin"} -> fini ; sans cette ligne -> interrompue ; le bilan des
# détecteurs et celui des outils en une page
flux = analyse.DOSSIER / "NORDEND_a" / "travail" / "optimisation.jsonl"
assert flux.read_text().endswith('{"type": "fin", "etat": "fini"}\n'), flux.read_text()
analyse.analyses.clear()
analyse.optimisations.clear()
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "fini"
flux.write_text('{"type": "assistant", "message": {"content": []}}\n')
analyse.optimisations.clear()
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "interrompue"
(analyse.DOSSIER / "NORDEND_a" / "detectors" / "20261113T1000Z").mkdir(parents=True)
(analyse.DOSSIER / "NORDEND_a" / "detectors" / "20261113T1000Z" / "summary.md").write_text("# wf-improve\n\n**Result**: none")
(analyse.DOSSIER / "NORDEND_a" / "outils.md").write_text("# Outils\n\n**Outils modifiés** : aucun")
assert analyse.etat("NORDEND_a")["optimisation"]["bilan"]
page = analyse.bilan("NORDEND_a", False)
assert "<strong>Result</strong>" in page and "<strong>Outils modifiés</strong>" in page, page
assert analyse.etat("NORDEND_b")["optimisation"] is None
finally:
fin.set()
shutil.rmtree(analyse.DOSSIER)
analyse.DOSSIER, analyse.subprocess.Popen = avant
analyse.analyses.clear()
analyse.optimisations.clear()
CHECKS = [check_serveur, check_station, check_optimisation]
if __name__ == "__main__":
nom = sys.argv[1] if len(sys.argv) > 1 else None
for f in CHECKS:
if nom in (None, f.__name__):
f()
print("ok", f.__name__)
-165
View File
@@ -1,165 +0,0 @@
"""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'analyste, et l'optimisation
des détecteurs (analyse.py).
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_PORT (port, 8770).
"""
import json
import os
import platform
import subprocess
import sys
import threading
import webbrowser
from pathlib import Path
import uvicorn
from fastapi import FastAPI, Query, Request
from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
import analyse
import station
from fastapi.staticfiles import StaticFiles
APP = Path(__file__).resolve().parents[1]
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit pas les données
PAGE = APP / "web" / "dist"
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def erreur(code: int, texte: str) -> JSONResponse:
return JSONResponse({"erreur": texte}, code)
@app.middleware("http")
async def garde(request: Request, suite):
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
hote = request.headers.get("host", "").rsplit(":", 1)[0]
if hote not in HOTES or (request.method in ("POST", "PUT", "DELETE")
and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée")
return await suite(request)
# --- la page Data (station.py)
@app.exception_handler(station.Refus)
def refus(_, e):
return erreur(400, str(e))
@app.get("/api/stations")
def stations():
return station.stations()
@app.get("/api/images")
def images(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.images(station_, du, au)
@app.get("/api/image/{station_}/{nom}")
def image(station_: str, nom: str):
return FileResponse(station.image(station_, nom), headers={"Cache-Control": "max-age=86400"})
@app.get("/api/courbes")
def courbes(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.courbes(station_, du, au)
@app.get("/api/detecteurs")
def detecteurs(station_: str = Query(alias="station"), du: str = "", au: str = "", cibles: str = ""):
return station.detecteurs(station_, du, au, cibles)
@app.get("/api/etiquettes")
def etiquettes(station_: str = Query(alias="station"), dossier: str = "manual"):
try:
return station.lire(station_, dossier)
except json.JSONDecodeError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
return erreur(500, f"labeling/{dossier}/{station_}.jsonl illisible : {e}")
@app.post("/api/etiquettes")
def ajouter(corps: dict):
return station.ajouter(corps)
@app.put("/api/etiquettes")
def modifier(corps: dict):
return station.modifier(corps)
@app.delete("/api/etiquettes")
def supprimer(corps: dict):
return station.supprimer(corps)
# --- 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):
return analyse.lancer(corps)
@app.get("/api/analyses")
def analyses():
return analyse.liste()
@app.get("/api/analyses/{nom}")
def etat_analyse(nom: str):
return analyse.etat(nom)
@app.post("/api/analyses/{nom}/message")
def message_analyse(nom: str, corps: dict):
return analyse.message(nom, corps)
@app.get("/api/analyses/{nom}/rapport.html")
def rapport_analyse(nom: str, sombre: bool = False):
return HTMLResponse(analyse.rapport(nom, sombre))
@app.post("/api/analyses/{nom}/optimiser")
def optimiser_analyse(nom: str):
return analyse.optimiser(nom)
@app.get("/api/analyses/{nom}/bilan.html")
def bilan_analyse(nom: str, sombre: bool = False):
return HTMLResponse(analyse.bilan(nom, sombre))
@app.get("/api/analyses/{nom}/{chemin:path}")
def fichier_analyse(nom: str, chemin: str):
return FileResponse(analyse.fichier(nom, chemin))
if PAGE.is_dir():
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
else:
@app.get("/")
def sans_page():
return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build")
def ouvrir(url: str) -> None:
if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
else:
webbrowser.open(url)
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
print(f"Diagnostic AIMsight : {url}")
if "--sans-navigateur" not in sys.argv:
threading.Timer(1, ouvrir, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)
-337
View File
@@ -1,337 +0,0 @@
"""Les données de la page Data : les images d'une station, ses courbes, ses étiquettes.
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
import csv
import glob
import json
import os
import re
import statistics
import sys
from datetime import datetime, timedelta
from pathlib import Path
RACINE = Path(__file__).resolve().parents[2]
sys.path[:0] = [str(RACINE / "agent-tools"), str(RACINE / "detectors" / "scripts")]
import donnees # noqa: E402
from categories import events # noqa: E402
# data/ et labeling/ sont des liens vers ~/aimsight-data/data et ~/labeling : pas de resolve(), les agents voient data/ et labeling/
DONNEES = Path(os.environ.get("AIMSIGHT_DATA", RACINE / "data")).absolute()
ETIQUETTES = Path(os.environ.get("AIMSIGHT_LABELS", RACINE / "labeling")).absolute()
def liens():
"""--add-dir pour claude -p : la cible réelle des liens data/ et labeling/, hors du dépôt."""
return [a for d in (DONNEES, ETIQUETTES) for a in ("--add-dir", str(d.resolve()))]
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
COULEURS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # un capteur chacun
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d"))
# Le menu Advanced d'Explore, dans son ordre (labeling.PLOTS, QUALITE)
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
QUALITE = (("peak", "Quality: Peak"), ("flux", "Quality: Flux"), ("sharpness", "Quality: Sharpness"),
("fwhm", "Quality: FWHM [px]"), ("dominance", "Quality: Dominance"), ("snr", "Quality: SNR"))
IDENTIFIANT = re.compile(r"(SIM_CCID|ip(_.*)?)$") # jamais lus (CLAUDE.md, « data/ »)
METRIQUE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
class Refus(ValueError):
"""Une demande à refuser (400), avec sa raison."""
def stations():
return sorted(d.name for d in DONNEES.iterdir() if d.is_dir())
def dossier(station):
if station not in stations(): # le nom devient un chemin : un dossier de data/, rien d'autre
raise Refus(f"station inconnue : {station}")
return DONNEES / station
def bornes(du, au):
return donnees.instant(du or "0001-01-01"), donnees.instant(au or "9999-01-01")
# --- 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)."""
maisons = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in mesures.items()
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
return maisons if any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()) else {}
def references(mesures, a, b):
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (références seulement)."""
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
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,
corr_y à l'heure de chaque image : la mesure valide la plus proche, à 30 min près, sinon 0."""
d, (a, b) = dossier(station), bornes(du, au)
vues = [(t, im) for im in sorted(glob.glob(str(d / "images" / "*"))) if (t := donnees.heure_image(im)) and a <= t < b]
if not vues:
raise Refus(f"aucune image de {station} sur cette plage")
mesures = donnees.charger(d)
maisons, refs = positions(mesures, a, b), references(mesures, a, b)
# ponytail: une seule mesure à chaque borne, bruitée ; une médiane sur une fenêtre si les flèches tremblent trop
marge, corr = timedelta(minutes=30), {}
for s in maisons:
serie = [(m["t"], m["corr_x"], m["corr_y"]) for m in mesures[s] if m["corr_x"] is not None and m["corr_y"] is not None]
temps, corr[s] = [m[0] for m in serie], []
for t, _ in vues:
k = bisect.bisect_left(temps, t)
k = min((n for n in (k - 1, k) if 0 <= n < len(serie)), key=lambda n: abs(temps[n] - t), default=None)
corr[s].append([round(serie[k][1], 4), round(serie[k][2], 4)] if k is not None and abs(temps[k] - t) <= marge else 0)
return {"images": [{"t": donnees.iso(t).replace("T", " ").rstrip("Z"), "nom": os.path.basename(im)} for t, im in vues],
"positions": {s: [round(x, 1), round(y, 1)] for s, (x, y) in sorted(maisons.items())},
"references": sorted(refs), "corr": corr}
def image(station, nom):
f = (dossier(station) / "images" / nom).resolve()
if f.parent != (DONNEES / station / "images").resolve() or not f.is_file():
raise Refus("image inconnue")
return f
# --- 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
trou se voit), sans les métriques texte, les identifiants, ni celles qui n'ont aucune valeur."""
station, series, texte = d.name + "_", {}, set()
for p in sorted(glob.glob(str(d / "metrics" / "*.csv"))):
if not (m := METRIQUE.match(os.path.basename(p))) or IDENTIFIANT.match(nom := m.group(1).removeprefix(station)):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
t, v = donnees.instant(r["time_utc"]), (r.get("metric") or "").strip("[]'\" ")
if not a <= t < b:
continue
try:
series.setdefault(nom, {})[t] = float(v) if v else None
except ValueError:
texte.add(nom) # link, mode… : pas de courbe
return {n: dict(sorted(s.items())) for n, s in series.items()
if n not in texte and any(v is not None for v in s.values())}
def plage(mesures, du, au):
"""La plage lue : de du à au (exclu), sinon de la première mesure à la dernière, plus un pas."""
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
a = donnees.instant(du) if du else tous[0]
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2] if len(tous) > 1 else timedelta(hours=1))
return a, b
def courbes(station, du, au):
"""-> {A, B, T, plots} : T, les heures de chaque série, une fois (clé : le capteur, "" pour la caméra, « system: »
et son nom pour une métrique) ; plot : titre et traces (name, t, y, line, mode), sans plots ni capteurs vides."""
d = dossier(station)
mesures = donnees.charger(d)
if not mesures:
raise Refus(f"aucun export « advanced » pour {station}")
a, b = plage(mesures, du, au)
poses = [p for p in donnees.charger_camera(d) if a <= p["t"] < b]
heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly)
valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)}
refs, out = references(mesures, a, b), []
def par_capteur(colonnes):
for col, titre in colonnes:
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": COULEURS[i % len(COULEURS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate((s, valeurs(ms, col)) for s, ms in dans.items()) if any(v is not None for v in y)]
if traces:
out.append({"titre": titre, "traces": traces})
par_capteur(PLOTS)
if poses:
out.append({"titre": "Camera movement (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c),
"line": {"width": 1.2, "color": col}} for c, col in POSE]})
par_capteur(QUALITE)
T = {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}
systeme = metriques(d, a, b)
for nom in sorted(systeme, key=str.lower):
T["system:" + nom] = [heure(t) for t in systeme[nom]]
out.append({"titre": "System: " + nom, "traces": [{"name": nom, "t": "system:" + nom, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in systeme[nom].values()],
"line": {"width": 1.2, "color": COULEURS[0]}}]})
if not out:
raise Refus(f"aucune mesure de {station} sur cette plage")
return {"A": donnees.iso(a), "B": donnees.iso(b), "T": T, "plots": out}
# --- la page Data, étiquettes « Detectors » : les événements du journal, en lecture seule
HISTORIQUE = timedelta(days=3) # jours d'avant donnés aux détecteurs, comme categories.py (règle du 2026-10-24)
# ponytail: gardés jusqu'au redémarrage du serveur (une minute ou plus par plage) ; relancer après un /detectors:wf-improve lancé hors de l'app
@functools.lru_cache(maxsize=32)
def detecteurs(station, du, au, cibles=""):
"""-> les événements des détecteurs sur la plage, au format des étiquettes (debut, fin, categorie, description) ;
plus sorte, capteurs, ignore (zone grisée du journal). cibles : les capteurs gardés, séparés par des virgules (vide :
tous) ; les autres sont écartés avant les détecteurs, comme s'ils n'existaient pas."""
d = dossier(station)
tout = donnees.charger(d)
if cibles:
garde = set(cibles.split(","))
tout = {s: ms for s, ms in tout.items() if s in garde}
if not tout:
raise Refus(f"aucun export « advanced » pour {station}" + " avec ces cibles" * bool(cibles))
a, b = plage(tout, du, au)
mesures = {s: k for s, ms in tout.items() if (k := [m for m in ms if a - HISTORIQUE <= m["t"] < b])}
evs = [v for v in events(mesures, b, str(d)) if v["end"] >= donnees.iso(a)] if mesures else []
refs = {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"}
return [{"id": f"D-{i + 1}", "debut": v["start"], "fin": v["end"], "categorie": v["category"], "sorte": v["episodes"][0]["label"],
"description": f"{v['episodes'][0]['label']}. {v['text']}", "capteurs": v["sensors"], "ignore": v["ignore"],
"cibles": [s for s in v["sensors"] if s not in refs], "references": [s for s in v["sensors"] if s in refs],
"message": message(v["text"]), "action": action(v)}
for i, v in enumerate(evs)]
def message(texte):
"""Ce qui arrive : la première phrase du journal (detectors/scripts/categories.py, sentence), jusqu'à son « ; » ; la suite y dit quoi
en faire, sauf la phrase des sauts absorbés, gardée. ". " seulement : « 1.5× » ou « 0.30 px » ne coupent pas."""
meme = re.search(r" (The jumps? of .* same cause\.)$", texte)
return re.split(r"\. |; ", texte, maxsplit=1)[0].rstrip(".") + "." + (" " + meme.group(1) if meme else "")
# Quoi en faire : la colonne « Pour le client » de labeling/familles.md, par famille ; précisée par sorte (le label de l'épisode
# principal, avec son niveau) d'après les phrases du journal validées le 2026-10-24 (detectors/scripts/categories.py, sentence)
ACTION_FAMILLE = {
"Visibility": "Do not trust the curves in this period: this is not a movement.",
"Obstruction": "Ignore the curves of the hidden targets in this period.",
"Thermal displacement": "Normal, nothing to do.",
"Displacement": "To check: look at the images, then keep watching.",
"Target issue": "Act on the target (prism, mount); ignore its curve in the meantime.",
"No data": "The curves are missing in this period; its cause tells whether to act.",
}
ACTION_SORTE = {
"Poor visibility reduced": "Use the data in this period with care: they are less precise.",
"Heat shimmer": "Nothing to do: the small fast wiggles are not movement.",
"Camera thermal movement": "Nothing to do: this is not a movement of the structure.",
"Brief obstruction": "Ignore this single point on the curves.",
"Sudden jump, back to normal": "Look at the images: the cause is not established.",
"Lasting shift": "Check whether the structure moved: look at the images.",
"Jump, not back yet": "Check whether the structure moved: look at the images.",
"Large shift": "Check whether the structure moved: look at the images.",
"Slow drift": "Keep watching it.",
}
def action(v):
ep = v["episodes"][0]
return ACTION_SORTE.get(f"{ep['label']} {ep.get('level') or ''}".strip(), ACTION_SORTE.get(ep["label"])) \
or ACTION_FAMILLE.get(v["category"], "")
# --- les étiquettes
def fichier(station, source):
if source not in DOSSIERS:
raise Refus("dossier d'étiquettes inconnu")
dossier(station)
return ETIQUETTES / source / f"{station}.jsonl"
def lire(station, source):
f = fichier(station, source)
# split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
def attribuer(station, etiquettes):
"""labeling/ids.attribuer (D-131) : un id aux étiquettes qui n'en ont pas, le suivant de la station, en premier champ."""
n = max((int(e["id"].rsplit("-", 1)[1]) for e in etiquettes if "id" in e), default=0)
for e in etiquettes:
if "id" not in e:
n += 1
e["id"] = f"{station}-{n}"
if next(iter(e)) != "id":
reste = {k: v for k, v in e.items() if k != "id"}
ident = e["id"]
e.clear()
e.update({"id": ident}, **reste)
def _valide(corps, debut, fin):
description = (corps.get("description") or "").strip()
try:
vide = datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT)
except (TypeError, ValueError):
raise Refus("bornes illisibles (AAAA-MM-JJTHH:MMZ)") from None
if not description or vide:
raise Refus("texte vide ou plage vide")
c = corps.get("categorie") or ""
if c and c not in FAMILLES:
raise Refus("famille inconnue")
return description, c
def ajouter(corps):
station, source = corps.get("station"), corps.get("dossier", "manual")
f = fichier(station, source)
description, c = _valide(corps, corps.get("debut"), corps.get("fin"))
label = {"debut": corps["debut"], "fin": corps["fin"]} | ({"categorie": c} if c else {}) | {"description": description}
if source == "auto": # une étiquette automatique porte un id stable, le suivant de sa station (D-131)
attribuer(station, lire(station, "auto") + [label])
f.parent.mkdir(parents=True, exist_ok=True)
avant = f.read_bytes() if f.exists() else b"" # une ligne retirée à la main peut laisser le fichier sans fin de ligne
with open(f, "ab") as sortie:
sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
def modifier(corps):
avant = corps.get("avant") or {}
debut, fin = corps.get("debut", avant.get("debut")), corps.get("fin", avant.get("fin"))
description, c = _valide(corps, debut, fin)
label = dict.fromkeys(("id", "debut", "fin", "categorie")) | avant | {"debut": debut, "fin": fin, "categorie": c,
"description": description}
if label["id"] is None:
del label["id"]
if not c:
del label["categorie"]
label.pop("revue", None) # changée : plus revue
return remplace(corps.get("station"), corps.get("dossier", "manual"), avant, label)
def supprimer(corps):
remplace(corps.get("station"), corps.get("dossier", "manual"), corps.get("avant"), None)
return corps.get("avant")
def remplace(station, source, avant, label):
"""Remplace l'étiquette avant par label (None : la retire), retrouvée par son contenu, pas par son rang : le fichier
a pu changer depuis le chargement de la page. Écrit à côté puis remplace : une coupure n'abîme pas le fichier."""
f = fichier(station, source)
lignes = f.read_text(encoding="utf-8").split("\n") if f.exists() else []
for i, ligne in enumerate(lignes):
if ligne.strip() and json.loads(ligne) == avant:
lignes[i:i + 1] = [] if label is None else [json.dumps(label, ensure_ascii=False)]
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("\n".join(lignes), encoding="utf-8")
os.replace(provisoire, f)
return label
raise Refus("cette étiquette n'est plus dans le fichier : recharger la page")
+3 -3
View File
@@ -1,14 +1,14 @@
<!doctype html>
<html lang="fr">
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Diagnostic AIMsight</title>
<title>AIMsight Diagnostic</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap" rel="stylesheet">
</head>
<body>
<div id="racine"></div>
<div id="root"></div>
<script type="module" src="/src/main.jsx"></script>
</body>
</html>
+66 -66
View File
@@ -5,40 +5,40 @@ import {
import { useDisclosure } from "@mantine/hooks";
import { IconChartLine, IconFolder, IconMoon, IconSun } from "@tabler/icons-react";
const Data = lazy(() => import("./pages/Data.jsx")); // Plotly, chargé seulement ici
const Data = lazy(() => import("./pages/Data.jsx")); // Plotly, loaded only here
const PAGES = [["data", "Data", IconChartLine]];
// L'adresse : #/<page>?station=…&du=…&au=… ; recharger garde la page et la sélection, Retour marche ; sans dates, les 5 derniers
// jours UTC, aujourd'hui compris (au exclu : demain)
const jour = n => new Date(Date.now() + n * 864e5).toISOString().slice(0, 10);
function lireAdresse() {
// The address: #/<page>?station=…&start=…&end=…; reloading keeps the page and the selection, Back works; without dates, the
// last 5 UTC days, today included (end excluded: tomorrow)
const day = n => new Date(Date.now() + n * 864e5).toISOString().slice(0, 10);
function readAddress() {
const [page, q = ""] = location.hash.replace(/^#\/?/, "").split("?");
const p = new URLSearchParams(q);
return { page: PAGES.some(([n]) => n === page) ? page : "data",
selection: { station: p.get("station") || "", du: p.get("du") || jour(-4), au: p.get("au") || jour(1) } };
selection: { station: p.get("station") || "", start: p.get("start") || day(-4), end: p.get("end") || day(1) } };
}
function adresse(page, s) {
function address(page, s) {
const q = new URLSearchParams(Object.entries(s).filter(([, v]) => v)).toString();
return `#/${page}${q ? "?" + q : ""}`;
}
function Entete({ mobile, bureau, basculer }) {
const { setColorScheme } = useMantineColorScheme(), schema = useComputedColorScheme("light");
function Header({ mobile, desktop, toggle }) {
const { setColorScheme } = useMantineColorScheme(), scheme = useComputedColorScheme("light");
return (
<AppShell.Header className="entete">
<AppShell.Header className="header">
<Group h="100%" px="md" justify="space-between" wrap="nowrap">
<Group gap="sm" wrap="nowrap">
<Burger opened={mobile} onClick={basculer.mobile} hiddenFrom="sm" size="sm" color="white" aria-label="Menu" />
<Burger opened={bureau} onClick={basculer.bureau} visibleFrom="sm" size="sm" color="white" aria-label="Barre latérale" />
<Burger opened={mobile} onClick={toggle.mobile} hiddenFrom="sm" size="sm" color="white" aria-label="Menu" />
<Burger opened={desktop} onClick={toggle.desktop} visibleFrom="sm" size="sm" color="white" aria-label="Sidebar" />
<Text fw={700} size="lg">AIMsight</Text>
<Text size="sm" opacity={0.6}>Diagnostic</Text>
</Group>
<Group gap="sm" wrap="nowrap">
<Tooltip label={schema === "dark" ? "Mode clair" : "Mode sombre"}>
<ActionIcon variant="subtle" color="white" size="lg" aria-label="Changer de thème"
onClick={() => setColorScheme(schema === "dark" ? "light" : "dark")}>
{schema === "dark" ? <IconSun size={20} /> : <IconMoon size={20} />}
<Tooltip label={scheme === "dark" ? "Light mode" : "Dark mode"}>
<ActionIcon variant="subtle" color="white" size="lg" aria-label="Change theme"
onClick={() => setColorScheme(scheme === "dark" ? "light" : "dark")}>
{scheme === "dark" ? <IconSun size={20} /> : <IconMoon size={20} />}
</ActionIcon>
</Tooltip>
</Group>
@@ -47,37 +47,37 @@ function Entete({ mobile, bureau, basculer }) {
);
}
// Les analyses de la page Data (labeling/auto/analyses/), relues toutes les 3 s : un dossier par station, ouvert d'office s'il en
// a une en cours, et dedans une analyse par plage ; un clic ouvre Data sur sa station et ses jours, et y montre son rapport
// La plage d'une analyse sur une ligne : « 01.11 · 10:30–11:40 » dans le jour, sinon « 04.11 21:12 – 07.11 14:12 » (UTC)
const jourMois = t => `${t.slice(8, 10)}.${t.slice(5, 7)}`, heure = t => t.slice(11, 16);
const plage = a => (a.debut.slice(0, 10) === a.fin.slice(0, 10)
? `${jourMois(a.debut)} · ${heure(a.debut)}–${heure(a.fin)}` : `${jourMois(a.debut)} ${heure(a.debut)} – ${jourMois(a.fin)} ${heure(a.fin)}`);
const COULEUR_ETAT = { fini: "teal", erreur: "red", interrompue: "gray" };
// L'état : une roue qui tourne en cours, sinon une pastille de couleur (son nom dans la bulle)
const Pastille = ({ etat }) => (etat === "en cours" ? <Loader size={10} color="orange" />
: <Tooltip label={etat}><ColorSwatch size={8} color={`var(--mantine-color-${COULEUR_ETAT[etat] || "gray"}-6)`} withShadow={false} /></Tooltip>);
function Analyses({ ouvrir }) {
const [liste, setListe] = useState([]);
// The analyses of the Data page (labeling/auto/analyses/), read again every 3 s: one folder per station, open by default if
// it has one running, and inside one analysis per range; a click opens Data on its station and its days, and shows its report there
// The range of an analysis on one line: "01.11 · 10:30–11:40" within the day, otherwise "04.11 21:12 – 07.11 14:12" (UTC)
const dayMonth = t => `${t.slice(8, 10)}.${t.slice(5, 7)}`, hour = t => t.slice(11, 16);
const range = a => (a.start.slice(0, 10) === a.end.slice(0, 10)
? `${dayMonth(a.start)} · ${hour(a.start)}–${hour(a.end)}` : `${dayMonth(a.start)} ${hour(a.start)} – ${dayMonth(a.end)} ${hour(a.end)}`);
const STATE_COLOR = { done: "teal", error: "red", interrupted: "gray" };
// The state: a spinning wheel while running, otherwise a coloured dot (its name in the tooltip)
const Dot = ({ state }) => (state === "running" ? <Loader size={10} color="orange" />
: <Tooltip label={state}><ColorSwatch size={8} color={`var(--mantine-color-${STATE_COLOR[state] || "gray"}-6)`} withShadow={false} /></Tooltip>);
function Analyses({ open }) {
const [list, setList] = useState([]);
useEffect(() => {
const lire = () => fetch("/api/analyses").then(r => r.ok && r.json()).then(l => l && setListe(l)).catch(() => {}); // en silence : toutes les 3 s
lire();
const minuterie = setInterval(lire, 3000);
return () => clearInterval(minuterie);
const read = () => fetch("/api/analyses").then(r => r.ok && r.json()).then(l => l && setList(l)).catch(() => {}); // silently: every 3 s
read();
const timer = setInterval(read, 3000);
return () => clearInterval(timer);
}, []);
if (!liste.length) return null;
const stations = [...new Set(liste.map(a => a.station))].sort();
if (!list.length) return null;
const stations = [...new Set(list.map(a => a.station))].sort();
return <>
<Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">Analyses (UTC)</Text>
{stations.map(st => {
const siennes = liste.filter(a => a.station === st), occupee = siennes.some(a => a.etat === "en cours");
// le chevron du dossier reste celui de Mantine : un rightSection prendrait sa place, et tournerait avec lui
const its = list.filter(a => a.station === st), busy = its.some(a => a.state === "running");
// the chevron of the folder stays Mantine's: a rightSection would take its place, and rotate with it
return (
<NavLink key={st} defaultOpened={occupee} childrenOffset={22} leftSection={<IconFolder size={16} />}
label={<Group gap={6} wrap="nowrap">{st}<Text span size="xs" c="dimmed">{siennes.length}</Text>{occupee && <Loader size={10} color="orange" />}</Group>}>
{siennes.map(a => (
<NavLink key={a.nom} py={4} onClick={() => ouvrir(a)} leftSection={<Pastille etat={a.etat} />}
label={<Text size="xs" ff="monospace" style={{ whiteSpace: "nowrap" }}>{plage(a)}</Text>} />
<NavLink key={st} defaultOpened={busy} childrenOffset={22} leftSection={<IconFolder size={16} />}
label={<Group gap={6} wrap="nowrap">{st}<Text span size="xs" c="dimmed">{its.length}</Text>{busy && <Loader size={10} color="orange" />}</Group>}>
{its.map(a => (
<NavLink key={a.name} py={4} onClick={() => open(a)} leftSection={<Dot state={a.state} />}
label={<Text size="xs" ff="monospace" style={{ whiteSpace: "nowrap" }}>{range(a)}</Text>} />
))}
</NavLink>
);
@@ -85,49 +85,49 @@ function Analyses({ ouvrir }) {
</>;
}
function Barre({ page, selection, fermer, ouvrir }) {
const titre = t => <Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">{t}</Text>;
function Sidebar({ page, selection, close, open }) {
const title = t => <Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">{t}</Text>;
return (
<AppShell.Navbar p="xs">
<ScrollArea type="scroll">
{titre("Pages")}
{PAGES.map(([n, nom, Icone]) => (
<NavLink key={n} label={nom} leftSection={<Icone size={18} />} active={page === n} onClick={fermer}
href={adresse(n, selection)} />
{title("Pages")}
{PAGES.map(([n, name, Icon]) => (
<NavLink key={n} label={name} leftSection={<Icon size={18} />} active={page === n} onClick={close}
href={address(n, selection)} />
))}
<Analyses ouvrir={a => { fermer(); ouvrir(a); }} />
<Analyses open={a => { close(); open(a); }} />
</ScrollArea>
</AppShell.Navbar>
);
}
export default function App() {
const [{ page, selection }, setLieu] = useState(lireAdresse);
const [mobile, { toggle: basculerMobile, close: fermerMobile }] = useDisclosure(false);
const [bureau, { toggle: basculerBureau }] = useDisclosure(true);
const [analyse, setAnalyse] = useState(null); // l'analyse dont Data montre le rapport
const [{ page, selection }, setPlace] = useState(readAddress);
const [mobile, { toggle: toggleMobile, close: closeMobile }] = useDisclosure(false);
const [desktop, { toggle: toggleDesktop }] = useDisclosure(true);
const [analysis, setAnalysis] = useState(null); // the analysis whose report Data shows
useEffect(() => {
const suivre = () => setLieu(lireAdresse());
addEventListener("hashchange", suivre);
return () => removeEventListener("hashchange", suivre);
const follow = () => setPlace(readAddress());
addEventListener("hashchange", follow);
return () => removeEventListener("hashchange", follow);
}, []);
const choisir = s => { location.hash = adresse(page, s); };
// Une analyse de la barre : Data sur sa station, des jours qui couvrent sa plage (sauf si la plage affichée les couvre déjà)
function ouvrirAnalyse(a) {
const s = selection, couvre = s.station === a.station && s.du <= a.debut.slice(0, 10) && a.fin < s.au;
const au = new Date(Date.parse(a.fin.slice(0, 10)) + 864e5).toISOString().slice(0, 10);
setAnalyse(a.nom);
location.hash = adresse("data", couvre ? s : { station: a.station, du: a.debut.slice(0, 10), au });
const choose = s => { location.hash = address(page, s); };
// An analysis of the sidebar: Data on its station, days that cover its range (unless the range shown already covers them)
function openAnalysis(a) {
const s = selection, covers = s.station === a.station && s.start <= a.start.slice(0, 10) && a.end < s.end;
const end = new Date(Date.parse(a.end.slice(0, 10)) + 864e5).toISOString().slice(0, 10);
setAnalysis(a.name);
location.hash = address("data", covers ? s : { station: a.station, start: a.start.slice(0, 10), end });
}
return (
<AppShell header={{ height: 64 }} padding="lg"
navbar={{ width: 260, breakpoint: "sm", collapsed: { mobile: !mobile, desktop: !bureau } }}>
<Entete mobile={mobile} bureau={bureau} basculer={{ mobile: basculerMobile, bureau: basculerBureau }} />
<Barre page={page} selection={selection} fermer={fermerMobile} ouvrir={ouvrirAnalyse} />
navbar={{ width: 260, breakpoint: "sm", collapsed: { mobile: !mobile, desktop: !desktop } }}>
<Header mobile={mobile} desktop={desktop} toggle={{ mobile: toggleMobile, desktop: toggleDesktop }} />
<Sidebar page={page} selection={selection} close={closeMobile} open={openAnalysis} />
<AppShell.Main bg="var(--mantine-color-default-hover)">
<Suspense fallback={<Loader m="xl" />}><Data selection={selection} choisir={choisir} analyse={analyse} setAnalyse={setAnalyse} /></Suspense>
<Suspense fallback={<Loader m="xl" />}><Data selection={selection} choose={choose} analysis={analysis} setAnalysis={setAnalysis} /></Suspense>
</AppShell.Main>
</AppShell>
);
+35
View File
@@ -0,0 +1,35 @@
import { useEffect, useState } from "react";
import { Button, Card, Group, Select, TextInput } from "@mantine/core";
import { notifications } from "@mantine/notifications";
// A request to the API; a refusal of the server shows as a notification -> the JSON returned, or null
export async function call(path, method = "GET", body) {
try {
const r = await fetch(path, body === undefined ? { method }
: { method, headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
const json = await r.json().catch(() => ({ error: r.statusText }));
if (r.ok) return json;
notifications.show({ color: "red", title: "Refused", message: json.error || r.statusText });
} catch (e) {
notifications.show({ color: "red", title: "Server unreachable", message: e.message });
}
return null;
}
// The station and the range (UTC, To excluded; empty: the whole period), shared by the pages through the address
export function Selector({ selection, choose }) {
const [stations, setStations] = useState([]), [s, setS] = useState(selection);
useEffect(() => { call("/api/stations").then(l => l && setStations(l)); }, []);
useEffect(() => setS(selection), [selection.station, selection.start, selection.end]);
return (
<Card shadow="sm" withBorder>
<Group align="flex-end" gap="md">
<Select label="Station" placeholder="Choose" data={stations} value={s.station || null} searchable w={200}
onChange={v => setS({ ...s, station: v || "" })} />
<TextInput label="From (UTC)" type="date" value={s.start} onChange={e => setS({ ...s, start: e.currentTarget.value })} />
<TextInput label="To (excluded)" type="date" value={s.end} onChange={e => setS({ ...s, end: e.currentTarget.value })} />
<Button onClick={() => choose(s)} disabled={!s.station}>Load</Button>
</Group>
</Card>
);
}
-52
View File
@@ -1,52 +0,0 @@
import { useEffect, useState } from "react";
import { Button, Card, Group, Select, Text, TextInput } from "@mantine/core";
import { notifications } from "@mantine/notifications";
// Une requête à l'API ; un refus du serveur s'affiche en notification -> le JSON rendu, ou null
export async function appel(chemin, methode = "GET", corps) {
try {
const r = await fetch(chemin, corps === undefined ? { method: methode }
: { method: methode, headers: { "Content-Type": "application/json" }, body: JSON.stringify(corps) });
const json = await r.json().catch(() => ({ erreur: r.statusText }));
if (r.ok) return json;
notifications.show({ color: "red", title: "Refusé", message: json.erreur || r.statusText });
} catch (e) {
notifications.show({ color: "red", title: "Serveur injoignable", message: e.message });
}
return null;
}
export const poster = async (chemin, corps) => (await appel(chemin, "POST", corps)) !== null;
export function Carte({ surtitre, titre, action, children, ...reste }) {
return (
<Card shadow="sm" padding={0} withBorder {...reste}>
<Group px="lg" py="md" justify="space-between" wrap="nowrap" style={{ borderBottom: "1px solid var(--mantine-color-default-border)" }}>
<div>
<Text size="xs" fw={700} tt="uppercase" c="dimmed">{surtitre}</Text>
<Text fw={500}>{titre}</Text>
</div>
{action}
</Group>
{children}
</Card>
);
}
// La station et la plage (UTC, Au exclue ; vides : toute la période), partagées par les pages via l'adresse
export function Selecteur({ selection, choisir }) {
const [stations, setStations] = useState([]), [s, setS] = useState(selection);
useEffect(() => { appel("/api/stations").then(l => l && setStations(l)); }, []);
useEffect(() => setS(selection), [selection.station, selection.du, selection.au]);
return (
<Card shadow="sm" withBorder>
<Group align="flex-end" gap="md">
<Select label="Station" placeholder="Choisir" data={stations} value={s.station || null} searchable w={200}
onChange={v => setS({ ...s, station: v || "" })} />
<TextInput label="Du (UTC)" type="date" value={s.du} onChange={e => setS({ ...s, du: e.currentTarget.value })} />
<TextInput label="Au (exclu)" type="date" value={s.au} onChange={e => setS({ ...s, au: e.currentTarget.value })} />
<Button onClick={() => choisir(s)} disabled={!s.station}>Charger</Button>
</Group>
</Card>
);
}
+2 -2
View File
@@ -6,7 +6,7 @@ import "@mantine/notifications/styles.css";
import "./style.css";
import App from "./App.jsx";
// Bleu primaire #5383ff (shade 5), la palette retenue pour la page
// Primary blue #5383ff (shade 5), the palette chosen for the page
const theme = createTheme({
primaryColor: "aimsight",
primaryShade: 5,
@@ -16,7 +16,7 @@ const theme = createTheme({
defaultRadius: "md",
});
createRoot(document.getElementById("racine")).render(
createRoot(document.getElementById("root")).render(
<MantineProvider theme={theme} defaultColorScheme="auto">
<Notifications position="top-right" />
<App />
+353 -352
View File
@@ -4,80 +4,80 @@ import {
useComputedColorScheme,
} from "@mantine/core";
import { IconPlus, IconX } from "@tabler/icons-react";
import { appel, Selecteur } from "../commun.jsx";
import { ImagesDe } from "./Images.jsx";
import { call, Selector } from "../common.jsx";
import { StationImages } from "./Images.jsx";
// 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
// étiquette et la met en évidence. À droite, les images de la station, et sous elles les paramètres du diagnostic.
const FAMILLES = { "Visibility": "#8ec5e8", "Obstruction": "#f0b072", "Thermal displacement": "#f08a7e", "Displacement": "#b39ddb",
// Data, the curve viewer and the labelling: one plot at the start, others to add or remove,
// all aligned in time; under them the labels: Detectors (the events of the journal), LLM (labeling/auto/, read-only)
// or Analysis (the same, to edit, delete; dragging on the bar selects a range, which the analyst diagnoses and
// labels; elsewhere, dragging zooms); a click opens a
// label and highlights it. On the right, the images of the station, and under them the diagnostic settings.
const FAMILIES = { "Visibility": "#8ec5e8", "Obstruction": "#f0b072", "Thermal displacement": "#f08a7e", "Displacement": "#b39ddb",
"Target issue": "#e6d46a", "No data": "#c4c4be", "None": "#a8d5a2" };
const NOM_FAMILLE = f => (f === "None" ? "None (courbes intactes)" : f);
const CHOIX_FAMILLE = [{ value: "", label: "(sans famille)" }, ...Object.keys(FAMILLES).map(f => ({ value: f, label: NOM_FAMILLE(f) }))];
// LLM et Analysis : les mêmes étiquettes, labeling/auto/ ; LLM les lit, Analysis les modifie, supprime, et en fait faire par
// l'analyste sur une plage (app/serveur/analyse.py)
const SOURCES = [{ value: "detecteurs", label: "Detectors" }, { value: "auto", label: "LLM" }, { value: "analysis", label: "Analysis" }];
const GRIS = "#b0b0aa", BLEU = "#2a78d6", VOIE = 26, HAUT = 330; // VOIE : px par rangée d'étiquettes ; HAUT : d'un plot
const couleur = l => FAMILLES[l.categorie] || GRIS;
const lisible = s => s.slice(0, 16).replace("T", " ");
const marge = () => ({ l: 60, r: 20, t: 10, b: 30 });
// L'habillage, aux couleurs de Mantine (dark.0 à dark.7 en sombre, gray en clair)
const COULEURS = { clair: { texte: "#495057", faible: "#868e96", grille: "#eef0f2", axe: "#dee2e6", fond: "#f1f3f5", bulle: "#ffffff", zone: 0.05 },
sombre: { texte: "#c9c9c9", faible: "#828282", grille: "#2e2e2e", axe: "#424242", fond: "#3b3b3b", bulle: "#242424", zone: 0.07 } };
const POLICE = "Roboto, sans-serif";
const habillage = c => ({ paper_bgcolor: "rgba(0,0,0,0)", plot_bgcolor: "rgba(0,0,0,0)", font: { family: POLICE, size: 11, color: c.texte },
hoverlabel: { bgcolor: c.bulle, bordercolor: c.axe, align: "left", font: { family: POLICE, size: 12, color: c.texte } },
modebar: { bgcolor: "rgba(0,0,0,0)", color: c.faible, activecolor: "#5383ff" } });
const axe = c => ({ gridcolor: c.grille, linecolor: c.axe, showline: true, zeroline: false, ticks: "" });
const OUTILS = { responsive: true, doubleClick: "reset", displaylogo: false, showTips: false,
const FAMILY_NAME = f => (f === "None" ? "None (curves intact)" : f);
const FAMILY_CHOICES = [{ value: "", label: "(no family)" }, ...Object.keys(FAMILIES).map(f => ({ value: f, label: FAMILY_NAME(f) }))];
// LLM and Analysis: the same labels, labeling/auto/; LLM reads them, Analysis edits, deletes them, and has the analyst make
// some on a range (app/server/analysis.py)
const SOURCES = [{ value: "detectors", label: "Detectors" }, { value: "auto", label: "LLM" }, { value: "analysis", label: "Analysis" }];
const GREY = "#b0b0aa", BLUE = "#2a78d6", LANE = 26, HEIGHT = 330; // LANE: px per row of labels; HEIGHT: of a plot
const color = l => FAMILIES[l.family] || GREY;
const readable = s => s.slice(0, 16).replace("T", " ");
const margin = () => ({ l: 60, r: 20, t: 10, b: 30 });
// The skin, in Mantine's colours (dark.0 to dark.7 in dark, gray in light)
const THEMES = { light: { text: "#495057", faint: "#868e96", grid: "#eef0f2", axis: "#dee2e6", bg: "#f1f3f5", tooltip: "#ffffff", zone: 0.05 },
dark: { text: "#c9c9c9", faint: "#828282", grid: "#2e2e2e", axis: "#424242", bg: "#3b3b3b", tooltip: "#242424", zone: 0.07 } };
const FONT = "Roboto, sans-serif";
const skin = c => ({ paper_bgcolor: "rgba(0,0,0,0)", plot_bgcolor: "rgba(0,0,0,0)", font: { family: FONT, size: 11, color: c.text },
hoverlabel: { bgcolor: c.tooltip, bordercolor: c.axis, align: "left", font: { family: FONT, size: 12, color: c.text } },
modebar: { bgcolor: "rgba(0,0,0,0)", color: c.faint, activecolor: "#5383ff" } });
const axis = c => ({ gridcolor: c.grid, linecolor: c.axis, showline: true, zeroline: false, ticks: "" });
const CONFIG = { responsive: true, doubleClick: "reset", displaylogo: false, showTips: false,
modeBarButtonsToRemove: ["lasso2d", "select2d", "autoScale2d", "zoomIn2d", "zoomOut2d", "hoverClosestCartesian", "hoverCompareCartesian", "toggleSpikelines"] };
const date = v => Date.parse(String(v).replace(" ", "T").replace(/Z?$/, "Z")); // une date Plotly ou d'étiquette -> ms UTC
const coupe = s => s.replace(/(.{1,80})(\s|$)/g, "$1<br>"); // la bulle : des lignes de 80 caractères au plus
const date = v => Date.parse(String(v).replace(" ", "T").replace(/Z?$/, "Z")); // a Plotly or label date -> ms UTC
const wrap = s => s.replace(/(.{1,80})(\s|$)/g, "$1<br>"); // the tooltip: lines of 80 characters at most
const DETECTEES = Object.keys(FAMILLES).filter(f => f !== "None"); // les familles des détecteurs (categories.py)
const DETECTED = Object.keys(FAMILIES).filter(f => f !== "None"); // the families of the detectors (categories.py)
export default function Data({ selection, choisir, analyse, setAnalyse }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false), [large, setLarge] = useState(false);
const gauche = useRef(), [instant, setInstant] = useState(null); // instant : où caler les images (le début de l'événement cliqué)
// Les paramètres du diagnostic, sous l'image (Detectors et LLM) : familles montrées (filtre de la page) ; cibles gardées ("" :
// toutes ; sinon les détecteurs retournent sans les autres)
const [source, setSource] = useState("detecteurs"), [familles, setFamilles] = useState(DETECTEES), [cibles, setCibles] = useState("");
const [focus, setFocus] = useState(false); // un événement ouvert : les plots ne montrent que ses capteurs
const { station, du, au } = selection;
export default function Data({ selection, choose, analysis, setAnalysis }) {
const [data, setData] = useState(null), [loading, setLoading] = useState(false), [wide, setWide] = useState(false);
const left = useRef(), [moment, setMoment] = useState(null); // moment: where to set the images (the start of the clicked event)
// The diagnostic settings, under the image (Detectors and LLM): families shown (filter of the page); targets kept ("":
// all; otherwise the detectors run again without the others)
const [source, setSource] = useState("detectors"), [families, setFamilies] = useState(DETECTED), [targets, setTargets] = useState("");
const [focus, setFocus] = useState(false); // with an event open, the plots show only its sensors
const { station, start, end } = selection;
useEffect(() => {
setDonnees(null); setCibles("");
setData(null); setTargets("");
if (!station) return;
setCharge(true);
appel(`/api/courbes?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
// Les colonnes glissent (style.css) ; Plotly ne suit que la fenêtre : à la fin du glissement, les plots se recalent sur leur
// nouvelle largeur (les redessiner à chaque image du glissement serait trop lourd)
const finGlissement = e => { if (e.target === gauche.current && e.propertyName === "max-width") dispatchEvent(new Event("resize")); };
setLoading(true);
call(`/api/curves?${new URLSearchParams({ station, start, end })}`).then(d => { setData(d); setLoading(false); });
}, [station, start, end]);
// The columns slide (style.css); Plotly only follows the window: at the end of the slide, the plots refit to their
// new width (redrawing them at every frame of the slide would be too heavy)
const slideEnd = e => { if (e.target === left.current && e.propertyName === "max-width") dispatchEvent(new Event("resize")); };
return (
<Grid gutter="lg" className="data-grille" onTransitionEnd={finGlissement}>
<Grid.Col span={{ base: 12, lg: large ? 5 : 8 }} ref={gauche}>
<Grid gutter="lg" className="data-grid" onTransitionEnd={slideEnd}>
<Grid.Col span={{ base: 12, lg: wide ? 5 : 8 }} ref={left}>
<Stack gap="lg">
<div>
<Title order={2}>Data</Title>
<Text c="dimmed">Les courbes d'une station, un plot ou plusieurs ; sous eux les étiquettes : un clic sur l'une la met en évidence et
l'ouvre.</Text>
<Text c="dimmed">The curves of a station, one plot or several; under them the labels: a click on one highlights it and
opens it.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Courbes key={`${station}${du}${au}`} selection={selection} d={donnees} caler={(t, proche) => setInstant({ t, proche })}
source={source} setSource={setSource} familles={familles} cibles={cibles} focus={focus}
analyse={analyse} setAnalyse={setAnalyse} />}
<Selector selection={selection} choose={choose} />
{loading && <Loader />}
{data && <Curves key={`${station}${start}${end}`} selection={selection} d={data} setImage={(t, nearest) => setMoment({ t, nearest })}
source={source} setSource={setSource} families={families} targets={targets} focus={focus}
analysis={analysis} setAnalysis={setAnalysis} />}
</Stack>
</Grid.Col>
<Grid.Col span={{ base: 12, lg: large ? 7 : 4 }}>
<div className="colle">
<Grid.Col span={{ base: 12, lg: wide ? 7 : 4 }}>
<div className="sticky">
<Stack gap="lg">
<ImagesDe selection={selection} compacte large={large} basculer={() => setLarge(!large)} instant={instant} />
{donnees && <Parametres key={`${station}${du}${au}`} d={donnees} familles={familles} setFamilles={setFamilles}
cibles={cibles} setCibles={setCibles} detect={source === "detecteurs"}
focus={focus} setFocus={setFocus} />}
<StationImages selection={selection} compact wide={wide} toggle={() => setWide(!wide)} moment={moment} />
{data && <Settings key={`${station}${start}${end}`} d={data} families={families} setFamilies={setFamilies}
targets={targets} setTargets={setTargets} detect={source === "detectors"}
focus={focus} setFocus={setFocus} />}
</Stack>
</div>
</Grid.Col>
@@ -85,97 +85,97 @@ export default function Data({ selection, choisir, analyse, setAnalyse }) {
);
}
// Les familles s'appliquent tout de suite (filtre de la page, Detectors et LLM) ; les cibles, au bouton : chaque jeu de cibles
// relance les détecteurs (les étiquettes LLM ne disent pas leurs capteurs : elles ne les filtrent pas)
function Parametres({ d, familles, setFamilles, cibles, setCibles, detect, focus, setFocus }) {
const capteurs = Object.keys(d.T).filter(k => k && !k.startsWith("system:"));
// The families apply at once (filter of the page, Detectors and LLM); the targets, with the button: each set of targets
// runs the detectors again (the LLM labels do not state their sensors: they do not filter them)
function Settings({ d, families, setFamilies, targets, setTargets, detect, focus, setFocus }) {
const sensors = Object.keys(d.T).filter(k => k && !k.startsWith("system:"));
const refs = new Set(d.plots.flatMap(p => p.traces).filter(t => t.name.endsWith(" (ref.)")).map(t => t.t));
const [coches, setCoches] = useState(cibles ? cibles.split(",") : capteurs);
const voulu = coches.length === capteurs.length ? "" : capteurs.filter(c => coches.includes(c)).join(",");
const [checked, setChecked] = useState(targets ? targets.split(",") : sensors);
const wanted = checked.length === sensors.length ? "" : sensors.filter(c => checked.includes(c)).join(",");
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<Title order={5}>Paramètres du diagnostic</Title>
<Switch label="Focus on event curves" description="Un événement ouvert : les plots ne montrent que ses capteurs"
<Title order={5}>Diagnostic settings</Title>
<Switch label="Focus on event curves" description="With an event open, the plots show only its sensors"
checked={focus} onChange={e => setFocus(e.currentTarget.checked)} />
<Checkbox.Group label="Familles montrées" value={familles} onChange={setFamilles}>
<Checkbox.Group label="Families shown" value={families} onChange={setFamilies}>
<SimpleGrid cols={2} spacing={6} verticalSpacing={6} mt={6}>
{DETECTEES.map(f => <Checkbox key={f} size="xs" value={f} label={f} color={FAMILLES[f]} iconColor="#1a1b1e" />)}
{DETECTED.map(f => <Checkbox key={f} size="xs" value={f} label={f} color={FAMILIES[f]} iconColor="#1a1b1e" />)}
</SimpleGrid>
</Checkbox.Group>
<Checkbox.Group label="Cibles considérées (les autres sont écartées)" value={coches} onChange={setCoches}>
<Checkbox.Group label="Targets considered (the others are removed)" value={checked} onChange={setChecked}>
<SimpleGrid cols={3} spacing={6} verticalSpacing={6} mt={6}>
{capteurs.map(c => <Checkbox key={c} size="xs" value={c} label={c + (refs.has(c) ? " (ref.)" : "")} />)}
{sensors.map(c => <Checkbox key={c} size="xs" value={c} label={c + (refs.has(c) ? " (ref.)" : "")} />)}
</SimpleGrid>
</Checkbox.Group>
{!detect && <Text size="xs" c="dimmed">Les étiquettes ne disent pas leurs cibles : ce choix ne vaut que pour Detectors.</Text>}
{!detect && <Text size="xs" c="dimmed">Labels do not state their targets: this choice applies to Detectors only.</Text>}
<Group gap="sm">
<Button size="xs" onClick={() => setCibles(voulu)} disabled={!coches.length || voulu === cibles}>Relancer les détecteurs</Button>
<Button size="xs" variant="default" onClick={() => setCoches(coches.length ? [] : capteurs)}>{coches.length ? "Tout décocher" : "Tout cocher"}</Button>
<Button size="xs" onClick={() => setTargets(wanted)} disabled={!checked.length || wanted === targets}>Rerun the detectors</Button>
<Button size="xs" variant="default" onClick={() => setChecked(checked.length ? [] : sensors)}>{checked.length ? "Uncheck all" : "Check all"}</Button>
</Group>
</Stack>
</Card>
);
}
// Une ligne de la fiche d'un événement des détecteurs : son nom, puis sa valeur
const Champ = ({ nom, children }) => (
// A line of the card of a detectors' event: its name, then its value
const Field = ({ name, children }) => (
<Group gap="sm" align="flex-start" wrap="nowrap">
<Text size="sm" c="dimmed" w={80} style={{ flexShrink: 0 }}>{nom}</Text>
<Text size="sm" c="dimmed" w={80} style={{ flexShrink: 0 }}>{name}</Text>
<Text size="sm" component="div">{children}</Text>
</Group>
);
// Les capteurs d'un événement : ceux des détecteurs, sinon ceux que nomme le texte de l'étiquette (LLM, Analysis)
const nomme = (texte, s) => new RegExp(`(^|[^\\w])${s.replace(/[^\w]/g, "\\$&")}(?![\\w])`).test(texte);
const capteursDe = (l, noms) => l.capteurs ?? noms.filter(s => nomme(l.description, s));
// The sensors of an event: those of the detectors, otherwise those the text of the label names (LLM, Analysis)
const mentions = (text, s) => new RegExp(`(^|[^\\w])${s.replace(/[^\w]/g, "\\$&")}(?![\\w])`).test(text);
const sensorsOf = (l, names) => l.sensors ?? names.filter(s => mentions(l.description, s));
// analyse : le dossier de l'analyse montrée, tenu par App (la barre latérale en ouvre une)
function Courbes({ selection: { station, du, au }, d, caler, source, setSource, familles, cibles, focus, analyse, setAnalyse }) {
// analysis: the folder of the analysis shown, held by App (the sidebar opens one)
function Curves({ selection: { station, start, end }, d, setImage, source, setSource, families, targets, focus, analysis, setAnalysis }) {
const { A, B, T, plots: PLOTS } = d;
const indice = (titre, sinon) => { const i = PLOTS.findIndex(p => p.titre === titre); return i < 0 ? sinon : i; };
const [Plotly, setPlotly] = useState(null), [pret, setPret] = useState(false);
const [vues, setVues] = useState([{ id: 1, m: indice("Relative Corrected Horizontal Shift", 0) }]); // les plots affichés
const [choix, setChoix] = useState(null);
const [indices, setIndices] = useState(""), [rev, setRev] = useState(0);
const [ouverte, setOuverte] = useState(null), [edit, setEdit] = useState(null), [note, setNote] = useState("");
const [toutes, setToutes] = useState([]), [lecture, setLecture] = useState(true), sombre = useComputedColorScheme("light") === "dark";
// toutes : le fichier (ou les détecteurs) ; labels : sur la plage, dans les familles cochées (sans famille ou None : toujours)
const labels = useMemo(() => toutes.filter(x => x.debut < B && x.fin > A
&& (!DETECTEES.includes(x.categorie) || familles.includes(x.categorie))), [toutes, familles]);
const detect = source === "detecteurs", lecteur = source !== "analysis"; // seul Analysis écrit
const dossier = source === "analysis" ? "auto" : source; // le dossier de labeling/ des étiquettes
// figs : id -> div du plot ; dessines : id -> plot qu'il montre ; vue : la plage et la largeur où le texte des étiquettes a été tronqué
const figs = useRef({}), dessines = useRef({}), prochain = useRef(2), barre = useRef(), tries = useRef([]), vue = useRef(""), courant = useRef({});
// le focus : les capteurs de l'événement ouvert (aucun : tous, comme pour No data) ; montres, leur clé
const noms = useMemo(() => Object.keys(T).filter(k => k && !k.startsWith("system:")), [T]);
const gardes = focus && ouverte ? capteursDe(ouverte, noms) : [], montres = gardes.join(",");
courant.current = { vues, labels, choix, ouverte, ouvrir, gardes: new Set(gardes), montres, c: COULEURS[sombre ? "sombre" : "clair"] }; // ce que lisent les événements Plotly
const plotIndex = (title, otherwise) => { const i = PLOTS.findIndex(p => p.title === title); return i < 0 ? otherwise : i; };
const [Plotly, setPlotly] = useState(null), [ready, setReady] = useState(false);
const [views, setViews] = useState([{ id: 1, m: plotIndex("Relative Corrected Horizontal Shift", 0) }]); // the plots shown
const [choice, setChoice] = useState(null);
const [hints, setHints] = useState(""), [rev, setRev] = useState(0);
const [opened, setOpened] = useState(null), [edit, setEdit] = useState(null), [note, setNote] = useState("");
const [allLabels, setAllLabels] = useState([]), [reading, setReading] = useState(true), dark = useComputedColorScheme("light") === "dark";
// allLabels: the file (or the detectors); labels: in the range, in the checked families (no family or None: always)
const labels = useMemo(() => allLabels.filter(x => x.start < B && x.end > A
&& (!DETECTED.includes(x.family) || families.includes(x.family))), [allLabels, families]);
const detect = source === "detectors", readOnly = source !== "analysis"; // only Analysis writes
const folder = source === "analysis" ? "auto" : source; // the labeling/ folder of the labels
// figs: id -> div of the plot; drawn: id -> plot it shows; viewKey: the range and the width where the text of the labels was truncated
const figs = useRef({}), drawn = useRef({}), nextId = useRef(2), bar = useRef(), sorted = useRef([]), viewKey = useRef(""), current = useRef({});
// the focus: the sensors of the open event (none: all, as for No data); shown, their key
const names = useMemo(() => Object.keys(T).filter(k => k && !k.startsWith("system:")), [T]);
const kept = focus && opened ? sensorsOf(opened, names) : [], shown = kept.join(",");
current.current = { views, labels, choice, opened, open, kept: new Set(kept), shown, c: THEMES[dark ? "dark" : "light"] }; // what the Plotly events read
useEffect(() => { import("plotly.js-dist-min").then(m => setPlotly(() => m.default)); }, []);
const liste = () => courant.current.vues.map(v => figs.current[v.id]).filter(g => g?._fullLayout);
const plotDivs = () => current.current.views.map(v => figs.current[v.id]).filter(g => g?._fullLayout);
// Les zones des étiquettes, la plage choisie, et l'étiquette ouverte : plus marquée, entourée
// The zones of the labels, the chosen range, and the open label: more marked, outlined
function zones() {
const { labels, choix, ouverte, c } = courant.current;
const z = (a, b, f, o, ligne = { width: 0 }, couche = "below") => ({ type: "rect", xref: "x", yref: "paper", x0: lisible(a), x1: lisible(b),
y0: 0, y1: 1, fillcolor: f, opacity: o, line: ligne, layer: couche });
return labels.map(l => z(l.debut, l.fin, couleur(l), c.zone)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : [])
.concat(ouverte ? [z(ouverte.debut, ouverte.fin, couleur(ouverte), 0.3),
z(ouverte.debut, ouverte.fin, "rgba(0,0,0,0)", 1, { color: c.texte, width: 1.5, dash: "dot" }, "above")] : []);
const { labels, choice, opened, c } = current.current;
const z = (a, b, f, o, line = { width: 0 }, layer = "below") => ({ type: "rect", xref: "x", yref: "paper", x0: readable(a), x1: readable(b),
y0: 0, y1: 1, fillcolor: f, opacity: o, line, layer });
return labels.map(l => z(l.start, l.end, color(l), c.zone)).concat(choice ? [z(choice[0], choice[1], BLUE, 0.25)] : [])
.concat(opened ? [z(opened.start, opened.end, color(opened), 0.3),
z(opened.start, opened.end, "rgba(0,0,0,0)", 1, { color: c.text, width: 1.5, dash: "dot" }, "above")] : []);
}
// Le contour des barres : épais pour l'étiquette ouverte
const contour = t => {
const { ouverte, c } = courant.current;
return { color: t.map(l => (l === ouverte ? c.texte : c.fond)), width: t.map(l => (l === ouverte ? 3 : 1)) };
// The outline of the bars: thick for the open label
const outline = t => {
const { opened, c } = current.current;
return { color: t.map(l => (l === opened ? c.text : c.bg)), width: t.map(l => (l === opened ? 3 : 1)) };
};
// Les plots et la barre partagent plage et marges : celui qui change impose les siens aux autres (rien si déjà alignés,
// sinon le relayout appelle aligne en boucle).
function aligne(src) {
const gs = liste(), b = barre.current;
// The plots and the bar share range and margins: the one that changes imposes its own on the others (nothing if already
// aligned, otherwise the relayout calls align in a loop).
function align(src) {
const gs = plotDivs(), b = bar.current;
if (!b?._fullLayout || !gs.length) return;
const rg = (src?._fullLayout ? src : gs[0])._fullLayout.xaxis.range.slice();
const l = Math.max(...gs.map(g => g._fullLayout._size.l)), r = Math.max(...gs.map(g => g._fullLayout._size.r));
@@ -183,379 +183,380 @@ function Courbes({ selection: { station, du, au }, d, caler, source, setSource,
const m = g._fullLayout.margin, x = g._fullLayout.xaxis.range;
if (m.l === l && m.r === r && date(x[0]) === date(rg[0]) && date(x[1]) === date(rg[1])) return;
return Plotly.relayout(g, { "xaxis.range": rg, "margin.l": l, "margin.r": r });
})).then(recaleTexte);
})).then(refitText);
}
// Le texte des étiquettes suit le zoom et la largeur de la barre (rien si les deux n'ont pas changé)
function recaleTexte() {
const b = barre.current, L = b?._fullLayout;
// The text of the labels follows the zoom and the width of the bar (nothing if neither changed)
function refitText() {
const b = bar.current, L = b?._fullLayout;
if (!L) return;
const v = `${L.xaxis.range}|${L._size.w}`;
if (v !== vue.current) { vue.current = v; return Plotly.restyle(b, { text: [textes(tries.current, L)] }); }
if (v !== viewKey.current) { viewKey.current = v; return Plotly.restyle(b, { text: [texts(sorted.current, L)] }); }
}
// Le texte de chaque étiquette, tronqué à la largeur visible de sa barre (~6 px par caractère en 11 px) ; pour un événement
// des détecteurs, sa famille seulement (ses capteurs dans la bulle, le reste au clic)
function textes(t, L) {
// The text of each label, truncated to the visible width of its bar (~6 px per character at 11 px); for a detectors'
// event, its family only (its sensors in the tooltip, the rest on click)
function texts(t, L) {
const [r0, r1] = L.xaxis.range.map(date), w = L._size.w;
return t.map(l => {
const x = l.message ? l.categorie : l.description;
const px = (Math.min(date(l.fin), r1) - Math.max(date(l.debut), r0)) / (r1 - r0) * w, n = Math.floor((px - 10) / 6);
const x = l.message ? l.family : l.description;
const px = (Math.min(date(l.end), r1) - Math.max(date(l.start), r0)) / (r1 - r0) * w, n = Math.floor((px - 10) / 6);
return n < 3 ? "" : x.length <= n ? x : x.slice(0, n - 1) + "…";
});
}
// Une trace de capteur sous le focus : visible si c'est l'un des siens, sinon dans la légende seulement ; uirevision de la
// trace : le focus qui change l'emporte sur les clics de légende, qui restent tant qu'il ne change pas
function focalise(t) {
const { gardes, montres } = courant.current;
if (!montres || !t.t || t.t.startsWith("system:")) return { uirevision: montres || 1 };
return { visible: gardes.has(t.t) ? true : "legendonly", uirevision: montres };
// A sensor trace under the focus: visible if it is one of its own, otherwise in the legend only; uirevision of the
// trace: the focus that changes wins over legend clicks, which stay as long as it does not change
function focusTrace(t) {
const { kept, shown } = current.current;
if (!shown || !t.t || t.t.startsWith("system:")) return { uirevision: shown || 1 };
return { visible: kept.has(t.t) ? true : "legendonly", uirevision: shown };
}
function dessineFig(g, m) {
const p = PLOTS[m], { c } = courant.current, b = barre.current?._fullLayout;
g.style.height = `${HAUT}px`; // responsive : Plotly reprend la hauteur du div à chaque restyle, il lui en faut une
// uirevision : le zoom et les capteurs cachés restent quand on change de plot ; l'ordonnée, propre à chaque plot, se recale.
// Un nouveau plot prend la plage déjà affichée. t : la place du menu du plot (à gauche) et de la barre d'outils (à droite).
function drawFig(g, m) {
const p = PLOTS[m], { c } = current.current, b = bar.current?._fullLayout;
g.style.height = `${HEIGHT}px`; // responsive: Plotly takes the height of the div again at each restyle, it needs one
// uirevision: the zoom and the hidden sensors stay when the plot changes; the y axis, specific to each plot, refits.
// A new plot takes the range already shown. t: the room for the plot menu (left) and the toolbar (right).
return Plotly.react(g, p.traces.map(t => ({ type: "scatter", mode: t.mode || "lines", marker: { size: 4 }, x: T[t.t], y: t.y, name: t.name,
uid: t.name.replace(/\W/g, "_"), line: t.line, ...focalise(t),
hovertemplate: `${t.name} : %{y}<br>%{x|%Y-%m-%d %H:%M} UTC<extra></extra>` })),
{ ...habillage(c), height: HAUT, hovermode: "closest", margin: { ...marge(), t: 42, b: 36 }, uirevision: 1, shapes: zones(),
uid: t.name.replace(/\W/g, "_"), line: t.line, ...focusTrace(t),
hovertemplate: `${t.name}: %{y}<br>%{x|%Y-%m-%d %H:%M} UTC<extra></extra>` })),
{ ...skin(c), height: HEIGHT, hovermode: "closest", margin: { ...margin(), t: 42, b: 36 }, uirevision: 1, shapes: zones(),
legend: { x: 1.01, y: 1, itemwidth: 30, font: { size: 11 } },
xaxis: { type: "date", range: b ? b.xaxis.range.slice() : [lisible(A), lisible(B)], ...axe(c) },
yaxis: { title: { text: p.titre, font: { size: 11, color: c.faible } }, uirevision: p.titre, ...axe(c) } },
OUTILS).then(() => {
if (!g.suivi) {
g.suivi = true;
g.on("plotly_relayout", () => aligne(g));
g.on("plotly_click", ev => caler(String(ev.points[0].x), true)); // un clic sur une courbe : l'image la plus proche
xaxis: { type: "date", range: b ? b.xaxis.range.slice() : [readable(A), readable(B)], ...axis(c) },
yaxis: { title: { text: p.title, font: { size: 11, color: c.faint } }, uirevision: p.title, ...axis(c) } },
CONFIG).then(() => {
if (!g.followed) {
g.followed = true;
g.on("plotly_relayout", () => align(g));
g.on("plotly_click", ev => setImage(String(ev.points[0].x), true)); // a click on a curve: the nearest image
}
return aligne(g);
return align(g);
});
}
// Les plots nouveaux ou changés (tous : au changement de thème)
function dessinePlots(tous) {
return Promise.all(courant.current.vues.filter(v => tous || dessines.current[v.id] !== v.m)
.map(v => { dessines.current[v.id] = v.m; return dessineFig(figs.current[v.id], v.m); }));
// The new or changed plots (all: when the theme changes)
function drawPlots(all) {
return Promise.all(current.current.views.filter(v => all || drawn.current[v.id] !== v.m)
.map(v => { drawn.current[v.id] = v.m; return drawFig(figs.current[v.id], v.m); }));
}
function dessineBarre() {
const t = [...courant.current.labels].sort((a, b) => (a.debut < b.debut ? -1 : 1));
tries.current = t;
const voies = [], voie = t.map(l => { // la première rangée libre, sinon une nouvelle
const r = voies.findIndex(f => f <= l.debut), i = r < 0 ? voies.length : r;
voies[i] = l.fin;
function drawBar() {
const t = [...current.current.labels].sort((a, b) => (a.start < b.start ? -1 : 1));
sorted.current = t;
const lanes = [], lane = t.map(l => { // the first free row, otherwise a new one
const r = lanes.findIndex(f => f <= l.start), i = r < 0 ? lanes.length : r;
lanes[i] = l.end;
return i;
});
const n = Math.max(1, voies.length), gs = liste(), f = gs[0]._fullLayout, { c } = courant.current;
vue.current = "";
barre.current.style.height = `${40 + VOIE * n}px`; // comme les plots
return Plotly.react(barre.current, [{ type: "bar", orientation: "h", y: voie, base: t.map(l => lisible(l.debut)),
x: t.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.8,
marker: { color: t.map(couleur), cornerradius: 4, line: contour(t) },
text: textes(t, barre.current._fullLayout || f), textposition: "inside", insidetextanchor: "start", textangle: 0,
textfont: { family: POLICE, size: 11, color: "#1a1b1e" },
unselected: { marker: { opacity: 1 } }, // sinon une sélection les pâlit
// la bulle : pour un détecteur, ses cibles seulement ; sinon la famille et tout le texte, que la barre tronque
customdata: t.map(l => (l.message ? coupe(l.cibles.length ? l.cibles.join(", ") : l.references.length
? l.references.map(s => s + " (ref.)").join(", ") : "Tous les capteurs")
: (l.categorie ? `<b>${NOM_FAMILLE(l.categorie)}</b><br>` : "") + coupe(l.description))),
const n = Math.max(1, lanes.length), gs = plotDivs(), f = gs[0]._fullLayout, { c } = current.current;
viewKey.current = "";
bar.current.style.height = `${40 + LANE * n}px`; // as the plots
return Plotly.react(bar.current, [{ type: "bar", orientation: "h", y: lane, base: t.map(l => readable(l.start)),
x: t.map(l => Date.parse(l.end) - Date.parse(l.start)), width: 0.8,
marker: { color: t.map(color), cornerradius: 4, line: outline(t) },
text: texts(t, bar.current._fullLayout || f), textposition: "inside", insidetextanchor: "start", textangle: 0,
textfont: { family: FONT, size: 11, color: "#1a1b1e" },
unselected: { marker: { opacity: 1 } }, // otherwise a selection fades them
// the tooltip: for a detector, its targets only; otherwise the family and the whole text, which the bar truncates
customdata: t.map(l => (l.message ? wrap(l.targets.length ? l.targets.join(", ") : l.references.length
? l.references.map(s => s + " (ref.)").join(", ") : "All sensors")
: (l.family ? `<b>${FAMILY_NAME(l.family)}</b><br>` : "") + wrap(l.description))),
hovertemplate: "%{customdata}<extra></extra>" }],
{ ...habillage(c), height: 40 + VOIE * n, dragmode: lecteur ? "zoom" : "select", selectdirection: "h", hovermode: "closest", plot_bgcolor: c.fond, showlegend: false,
margin: { ...marge(), l: Math.max(...gs.map(g => g._fullLayout._size.l)), r: Math.max(...gs.map(g => g._fullLayout._size.r)) },
xaxis: { type: "date", range: f.xaxis.range.slice(), showgrid: false, ticks: "", color: c.texte },
{ ...skin(c), height: 40 + LANE * n, dragmode: readOnly ? "zoom" : "select", selectdirection: "h", hovermode: "closest", plot_bgcolor: c.bg, showlegend: false,
margin: { ...margin(), l: Math.max(...gs.map(g => g._fullLayout._size.l)), r: Math.max(...gs.map(g => g._fullLayout._size.r)) },
xaxis: { type: "date", range: f.xaxis.range.slice(), showgrid: false, ticks: "", color: c.text },
yaxis: { range: [n - 0.5, -0.5], fixedrange: true, showticklabels: false, showgrid: false, zeroline: false },
newselection: { line: { color: BLEU, width: 1 } }, activeselection: { fillcolor: BLEU, opacity: 0.25 } },
newselection: { line: { color: BLUE, width: 1 } }, activeselection: { fillcolor: BLUE, opacity: 0.25 } },
{ responsive: true, displayModeBar: false, doubleClick: false });
}
// Le premier dessin, puis les événements de la barre, une fois
// The first drawing, then the events of the bar, once
useEffect(() => {
if (!Plotly) return;
dessinePlots().then(dessineBarre).then(() => aligne()).then(() => {
barre.current.on("plotly_selected", ev => {
drawPlots().then(drawBar).then(() => align()).then(() => {
bar.current.on("plotly_selected", ev => {
const r = ev?.range?.x;
if (r) setChoix(r.map(v => String(v).slice(0, 16).replace(" ", "T") + "Z"));
if (r) setChoice(r.map(v => String(v).slice(0, 16).replace(" ", "T") + "Z"));
});
barre.current.on("plotly_deselect", () => setChoix(null));
barre.current.on("plotly_relayout", () => aligne(barre.current)); // zoomée (Detectors, LLM) ou redimensionnée seule (l'image agrandie)
// Un clic sur une étiquette l'ouvre ; un clic ailleurs sur la barre (pas un glisser) la referme
let surEtiquette = false, x0 = 0;
barre.current.on("plotly_click", ev => { surEtiquette = true; courant.current.ouvrir(tries.current[ev.points[0].pointIndex]); });
barre.current.addEventListener("mousedown", e => { x0 = e.clientX; }, true);
barre.current.addEventListener("click", e => {
if (!surEtiquette && Math.abs(e.clientX - x0) < 4) courant.current.ouvrir(null);
surEtiquette = false;
bar.current.on("plotly_deselect", () => setChoice(null));
bar.current.on("plotly_relayout", () => align(bar.current)); // zoomed (Detectors, LLM) or resized alone (the image enlarged)
// A click on a label opens it; a click elsewhere on the bar (not a drag) closes it
let onLabel = false, x0 = 0;
bar.current.on("plotly_click", ev => { onLabel = true; current.current.open(sorted.current[ev.points[0].pointIndex]); });
bar.current.addEventListener("mousedown", e => { x0 = e.clientX; }, true);
bar.current.addEventListener("click", e => {
if (!onLabel && Math.abs(e.clientX - x0) < 4) current.current.open(null);
onLabel = false;
});
setPret(true);
setReady(true);
});
return () => [...Object.values(figs.current), barre.current].forEach(g => g && Plotly.purge(g));
return () => [...Object.values(figs.current), bar.current].forEach(g => g && Plotly.purge(g));
}, [Plotly]);
useEffect(() => { if (pret) dessinePlots().then(() => aligne(barre.current)); }, [vues]);
useEffect(() => { if (pret) dessineBarre(); }, [pret, labels]);
// Glisser sur la barre : sélectionner une plage (Labelling), sinon zoomer dans le temps
useEffect(() => { if (pret) Plotly.relayout(barre.current, { dragmode: lecteur ? "zoom" : "select", selections: [] }); }, [pret, lecteur]);
useEffect(() => { if (pret) dessinePlots(true).then(dessineBarre); }, [sombre]);
useEffect(() => { if (pret) dessinePlots(true); }, [montres]);
useEffect(() => { if (pret) liste().forEach(g => Plotly.relayout(g, { shapes: zones() })); }, [pret, labels, choix, ouverte]);
useEffect(() => { if (ready) drawPlots().then(() => align(bar.current)); }, [views]);
useEffect(() => { if (ready) drawBar(); }, [ready, labels]);
// Drag on the bar: select a range (Analysis), otherwise zoom in time
useEffect(() => { if (ready) Plotly.relayout(bar.current, { dragmode: readOnly ? "zoom" : "select", selections: [] }); }, [ready, readOnly]);
useEffect(() => { if (ready) drawPlots(true).then(drawBar); }, [dark]);
useEffect(() => { if (ready) drawPlots(true); }, [shown]);
useEffect(() => { if (ready) plotDivs().forEach(g => Plotly.relayout(g, { shapes: zones() })); }, [ready, labels, choice, opened]);
useEffect(() => {
if (!pret || !barre.current._fullLayout) return;
const k = contour(tries.current);
Plotly.restyle(barre.current, { "marker.line.color": [k.color], "marker.line.width": [k.width] });
}, [ouverte]);
if (!ready || !bar.current._fullLayout) return;
const k = outline(sorted.current);
Plotly.restyle(bar.current, { "marker.line.color": [k.color], "marker.line.width": [k.width] });
}, [opened]);
// Lues à chaque chargement et à chaque changement de source : la page montre toujours le fichier ; les détecteurs tournent
// sur la plage la première fois (une minute ou plus), le serveur garde leur résultat
// Read at each load and at each change of source: the page always shows the file; the detectors run on the range the
// first time (a minute or more), the server keeps their result
useEffect(() => {
let vivant = true;
setLecture(true);
const url = source === "detecteurs" ? `/api/detecteurs?${new URLSearchParams({ station, du, au, cibles })}`
: `/api/etiquettes?${new URLSearchParams({ station, dossier })}`;
appel(url).then(l => {
if (!vivant) return; // une autre source a été choisie entre-temps
setLecture(false); setToutes(l || []);
let alive = true;
setReading(true);
const url = source === "detectors" ? `/api/detectors?${new URLSearchParams({ station, start, end, targets })}`
: `/api/labels?${new URLSearchParams({ station, folder })}`;
call(url).then(l => {
if (!alive) return; // another source was chosen in the meantime
setReading(false); setAllLabels(l || []);
});
return () => { vivant = false; };
}, [source, cibles, rev]);
return () => { alive = false; };
}, [source, targets, rev]);
// Un plot de plus : le premier que la page ne montre pas encore, déplacement vertical d'abord
function ajouterPlot() {
const pris = vues.map(v => v.m), id = prochain.current++;
const m = [indice("Relative Corrected Vertical Shift", 0), ...PLOTS.keys()].find(i => !pris.includes(i)) ?? 0;
setVues([...vues, { id, m }]);
// One more plot: the first one the page does not show yet, vertical displacement first
function addPlot() {
const taken = views.map(v => v.m), id = nextId.current++;
const m = [plotIndex("Relative Corrected Vertical Shift", 0), ...PLOTS.keys()].find(i => !taken.includes(i)) ?? 0;
setViews([...views, { id, m }]);
}
function enleverPlot(id) {
function removePlot(id) {
Plotly.purge(figs.current[id]);
delete figs.current[id]; delete dessines.current[id];
setVues(vues.filter(v => v.id !== id));
delete figs.current[id]; delete drawn.current[id];
setViews(views.filter(v => v.id !== id));
}
const modifiee = () => ouverte && edit && (edit.texte.trim() !== ouverte.description || edit.categorie !== (ouverte.categorie || "")
|| edit.debut + "Z" !== ouverte.debut || edit.fin + "Z" !== ouverte.fin);
const modified = () => opened && edit && (edit.text.trim() !== opened.description || edit.family !== (opened.family || "")
|| edit.start + "Z" !== opened.start || edit.end + "Z" !== opened.end);
// l : l'étiquette à afficher, null pour fermer -> false si Marc garde ses changements non enregistrés
function ouvrir(l) {
if (modifiee() && !confirm("Abandonner les changements de cette étiquette ?")) return false;
setOuverte(l); setNote("");
if (l) caler(l.debut); // un nouvel objet à chaque clic : recliquer le même événement y ramène les images
setEdit(l && !lecteur ? { debut: l.debut.slice(0, 16), fin: l.fin.slice(0, 16), categorie: l.categorie || "", texte: l.description } : null);
// l: the label to show, null to close -> false if Marc keeps his unsaved changes
function open(l) {
if (modified() && !confirm("Discard the changes to this label?")) return false;
setOpened(l); setNote("");
if (l) setImage(l.start); // a new object at each click: clicking the same event again brings the images back to it
setEdit(l && !readOnly ? { start: l.start.slice(0, 16), end: l.end.slice(0, 16), family: l.family || "", text: l.description } : null);
return true;
}
async function analyser() {
const r = await appel("/api/analyses", "POST", { station, debut: choix[0], fin: choix[1], indices });
if (!r) return; // rien n'est perdu : les indices et la plage restent dans la page
setAnalyse(r.nom); setIndices("");
await Plotly.relayout(barre.current, { selections: [] });
setChoix(null);
async function runAnalysis() {
const r = await call("/api/analyses", "POST", { station, start: choice[0], end: choice[1], hints });
if (!r) return; // nothing is lost: the hints and the range stay in the page
setAnalysis(r.name); setHints("");
await Plotly.relayout(bar.current, { selections: [] });
setChoice(null);
}
async function enregistrer() {
const l = await appel("/api/etiquettes", "PUT", { station, dossier, avant: ouverte, debut: edit.debut + "Z", fin: edit.fin + "Z",
categorie: edit.categorie, description: edit.texte.trim() });
if (!l) return; // rien n'est perdu : le texte et les bornes restent dans la fenêtre
setToutes(ls => ls.map(x => (x === ouverte ? l : x)));
setOuverte(l); setNote("Enregistrée");
async function save() {
const l = await call("/api/labels", "PUT", { station, folder, before: opened, start: edit.start + "Z", end: edit.end + "Z",
family: edit.family, description: edit.text.trim() });
if (!l) return; // nothing is lost: the text and the bounds stay in the window
setAllLabels(ls => ls.map(x => (x === opened ? l : x)));
setOpened(l); setNote("Saved");
}
async function supprimer() {
if (!confirm("Supprimer cette étiquette ?")) return;
if (await appel("/api/etiquettes", "DELETE", { station, dossier, avant: ouverte }) === null) return;
setToutes(ls => ls.filter(x => x !== ouverte));
setOuverte(null); setEdit(null);
async function remove() {
if (!confirm("Delete this label?")) return;
if (await call("/api/labels", "DELETE", { station, folder, before: opened }) === null) return;
setAllLabels(ls => ls.filter(x => x !== opened));
setOpened(null); setEdit(null);
}
const options = PLOTS.map((p, i) => ({ value: String(i), label: p.titre }));
const peutEnregistrer = modifiee() && edit.texte.trim() && edit.debut && edit.fin && edit.debut < edit.fin;
const bornes = (champ, plus) => lisible(toutes.reduce((m, l) => (plus(l[champ], m) ? l[champ] : m), toutes[0][champ]));
const options = PLOTS.map((p, i) => ({ value: String(i), label: p.title }));
const canSave = modified() && edit.text.trim() && edit.start && edit.end && edit.start < edit.end;
const extent = (field, beyond) => readable(allLabels.reduce((m, l) => (beyond(l[field], m) ? l[field] : m), allLabels[0][field]));
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<div>
{vues.map(v => (
{views.map(v => (
<div key={v.id} className="plot">
<div ref={el => { if (el) figs.current[v.id] = el; }} />
<Group gap={4} wrap="nowrap" className="plot-menu">
<NativeSelect size="xs" aria-label="Plot" data={options} value={String(v.m)} w={300}
onChange={e => { const m = +e.currentTarget.value; setVues(vues.map(x => (x.id === v.id ? { ...x, m } : x))); }} />
{vues.length > 1 && (
<Tooltip label="Enlever ce plot">
<ActionIcon variant="subtle" color="gray" aria-label="Enlever ce plot" onClick={() => enleverPlot(v.id)}><IconX size={16} /></ActionIcon>
onChange={e => { const m = +e.currentTarget.value; setViews(views.map(x => (x.id === v.id ? { ...x, m } : x))); }} />
{views.length > 1 && (
<Tooltip label="Remove this plot">
<ActionIcon variant="subtle" color="gray" aria-label="Remove this plot" onClick={() => removePlot(v.id)}><IconX size={16} /></ActionIcon>
</Tooltip>
)}
</Group>
</div>
))}
{!pret && <Loader size="sm" />}
{!ready && <Loader size="sm" />}
</div>
<Group justify="space-between" gap="sm">
<Group gap="sm">
<SegmentedControl size="xs" data={SOURCES} value={source} onChange={v => { if (ouvrir(null)) { setSource(v); setChoix(null); } }} />
{lecture && <Group gap={6}><Loader size="xs" /><Text size="xs" c="dimmed">{detect ? "Les détecteurs tournent sur la plage…" : "Lecture…"}</Text></Group>}
<SegmentedControl size="xs" data={SOURCES} value={source} onChange={v => { if (open(null)) { setSource(v); setChoice(null); } }} />
{reading && <Group gap={6}><Loader size="xs" /><Text size="xs" c="dimmed">{detect ? "The detectors are running on the range…" : "Reading…"}</Text></Group>}
</Group>
<Button size="xs" variant="light" leftSection={<IconPlus size={14} />} onClick={ajouterPlot} disabled={!pret}>Ajouter un plot</Button>
<Button size="xs" variant="light" leftSection={<IconPlus size={14} />} onClick={addPlot} disabled={!ready}>Add a plot</Button>
</Group>
<div ref={barre} />
{pret && !lecture && !labels.length && ( // sinon une barre vide ne dit pas pourquoi
<Text size="sm" c="orange">{detect ? `Les détecteurs ne trouvent aucun événement sur cette plage${toutes.length ? " dans les familles cochées" : ""}.`
: toutes.length ? `Aucune étiquette dans les familles cochées sur cette plage : celles de ${station} vont du ${bornes("debut", (a, b) => a < b)} au ${bornes("fin", (a, b) => a > b)} UTC.`
: `${station} n'a aucune étiquette dans labeling/${dossier}/.`}</Text>
<div ref={bar} />
{ready && !reading && !labels.length && ( // otherwise an empty bar does not say why
<Text size="sm" c="orange">{detect ? `The detectors find no event in this range${allLabels.length ? " in the checked families" : ""}.`
: allLabels.length ? `No label in the checked families in this range: those of ${station} go from ${extent("start", (a, b) => a < b)} to ${extent("end", (a, b) => a > b)} UTC.`
: `${station} has no label in labeling/${folder}/.`}</Text>
)}
<div>
{!ouverte && lecteur && <Text size="sm" c="dimmed">Cliquer sur un événement pour l'ouvrir.</Text>}
{ouverte && lecteur && (
{!opened && readOnly && <Text size="sm" c="dimmed">Click on an event to open it.</Text>}
{opened && readOnly && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap={6}>
<Group gap="xs">
<Badge color={couleur(ouverte)} c="#1a1b1e">{ouverte.categorie}</Badge>
<Text size="sm" fw={500}>{ouverte.sorte}</Text>
{ouverte.ignore && <Badge variant="outline" color="gray">grisé au journal</Badge>}
<Badge color={color(opened)} c="#1a1b1e">{opened.family}</Badge>
<Text size="sm" fw={500}>{opened.kind}</Text>
{opened.ignore && <Badge variant="outline" color="gray">greyed in the journal</Badge>}
</Group>
<Text size="sm" ff="monospace" fw={600}>{lisible(ouverte.debut)} → {lisible(ouverte.fin)} UTC</Text>
{ouverte.message ? <>
<Champ nom="Capteurs">{ouverte.capteurs.length ? <>
{ouverte.cibles.length > 0 && <div>Cibles ({ouverte.cibles.length}) : {ouverte.cibles.join(", ")}</div>}
{ouverte.references.length > 0 && <div>Références ({ouverte.references.length}) : {ouverte.references.join(", ")}</div>}
</> : "tous les capteurs"}</Champ>
<Champ nom="Message">{ouverte.message}</Champ>
<Champ nom="Action">{ouverte.action}</Champ>
</> : <Champ nom="Description">{ouverte.description}</Champ>}
<Text size="sm" ff="monospace" fw={600}>{readable(opened.start)} → {readable(opened.end)} UTC</Text>
{opened.message ? <>
<Field name="Sensors">{opened.sensors.length ? <>
{opened.targets.length > 0 && <div>Targets ({opened.targets.length}): {opened.targets.join(", ")}</div>}
{opened.references.length > 0 && <div>References ({opened.references.length}): {opened.references.join(", ")}</div>}
</> : "all sensors"}</Field>
<Field name="Message">{opened.message}</Field>
<Field name="Action">{opened.action}</Field>
</> : <Field name="Description">{opened.description}</Field>}
<Group>
<Button size="xs" variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button size="xs" variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
<Button size="xs" variant="default" onClick={() => open(null)}>Close</Button>
{opened.analysis && <Button size="xs" variant="light" onClick={() => setAnalysis(opened.analysis)}>View the report</Button>}
</Group>
</Stack>
</Card>
)}
{ouverte && edit && (
{opened && edit && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap="xs">
<Group gap="sm" align="flex-end">
<TextInput label="Du (UTC)" type="datetime-local" step={60} value={edit.debut} onChange={e => setEdit({ ...edit, debut: e.currentTarget.value })} />
<TextInput label="Au (UTC)" type="datetime-local" step={60} value={edit.fin} onChange={e => setEdit({ ...edit, fin: e.currentTarget.value })} />
<NativeSelect label="Famille" data={CHOIX_FAMILLE} value={edit.categorie} onChange={e => setEdit({ ...edit, categorie: e.currentTarget.value })} />
<TextInput label="From (UTC)" type="datetime-local" step={60} value={edit.start} onChange={e => setEdit({ ...edit, start: e.currentTarget.value })} />
<TextInput label="To (UTC)" type="datetime-local" step={60} value={edit.end} onChange={e => setEdit({ ...edit, end: e.currentTarget.value })} />
<NativeSelect label="Family" data={FAMILY_CHOICES} value={edit.family} onChange={e => setEdit({ ...edit, family: e.currentTarget.value })} />
</Group>
<Textarea autosize minRows={3} value={edit.texte} onChange={e => setEdit({ ...edit, texte: e.currentTarget.value })} />
<Textarea autosize minRows={3} value={edit.text} onChange={e => setEdit({ ...edit, text: e.currentTarget.value })} />
<Group gap="sm">
<Button onClick={enregistrer} disabled={!peutEnregistrer}>Enregistrer</Button>
<Button variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
<Button onClick={save} disabled={!canSave}>Save</Button>
<Button variant="default" onClick={() => open(null)}>Close</Button>
{opened.analysis && <Button variant="light" onClick={() => setAnalysis(opened.analysis)}>View the report</Button>}
<Text size="sm" c="teal">{note}</Text>
<Button color="red" variant="light" ml="auto" onClick={supprimer}>Supprimer</Button>
<Button color="red" variant="light" ml="auto" onClick={remove}>Delete</Button>
</Group>
</Stack>
</Card>
)}
</div>
{!lecteur && <>
<Text size="sm">{choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : "Glisser sur la barre des étiquettes pour sélectionner la plage à analyser."}</Text>
<Textarea autosize minRows={2} placeholder="Indices pour l'analyste (facultatif) : ce que tu as vu, ce qu'il faut regarder"
value={indices} onChange={e => setIndices(e.currentTarget.value)} />
<Group><Button onClick={analyser} disabled={!(choix && choix[0] < choix[1])}>Analyser la plage</Button></Group>
{!readOnly && <>
<Text size="sm">{choice ? `${readable(choice[0])} → ${readable(choice[1])} UTC` : "Drag on the label bar to select the range to analyze."}</Text>
<Textarea autosize minRows={2} placeholder="Hints for the analyst (optional): what you saw, what to look at"
value={hints} onChange={e => setHints(e.currentTarget.value)} />
<Group><Button onClick={runAnalysis} disabled={!(choice && choice[0] < choice[1])}>Analyze the range</Button></Group>
</>}
{analyse && <Analyse key={analyse} nom={analyse} sombre={sombre} fini={() => setRev(r => r + 1)} fermer={() => setAnalyse(null)} />}
{analysis && <Analysis key={analysis} name={analysis} dark={dark} done={() => setRev(r => r + 1)} close={() => setAnalysis(null)} />}
</Stack>
</Card>
);
}
// Le fil d'un agent (analyste, optimisation) : les messages de l'utilisateur (« › ») en gras, le reste en petit, défilé jusqu'en bas
function Fil({ lignes }) {
const fil = useRef();
useEffect(() => { if (fil.current) fil.current.scrollTop = fil.current.scrollHeight; }, [lignes.length]);
if (!lignes.length) return null;
// The thread of an agent (analyst, optimization): the user's messages ("› ") in bold, the rest small, scrolled to the bottom
function Thread({ lines }) {
const thread = useRef();
useEffect(() => { if (thread.current) thread.current.scrollTop = thread.current.scrollHeight; }, [lines.length]);
if (!lines.length) return null;
return (
<div ref={fil} style={{ maxHeight: 260, overflowY: "auto" }}>
{lignes.map((l, i) => l.startsWith("› ")
<div ref={thread} style={{ maxHeight: 260, overflowY: "auto" }}>
{lines.map((l, i) => l.startsWith("› ")
? <Text key={i} size="sm" fw={500} mt={6}>{l}</Text>
: <Text key={i} size="xs" ff="monospace" c="dimmed" style={{ whiteSpace: "pre-wrap" }}>{l}</Text>)}
</div>
);
}
// Un markdown rendu par le serveur (rapport, bilan), à la hauteur de son contenu une fois ses images chargées
function Page({ titre, src }) {
const cadre = useRef();
const ajuste = () => { const b = cadre.current?.contentDocument?.body; if (b) cadre.current.style.height = `${b.scrollHeight + 20}px`; };
return <iframe ref={cadre} title={titre} sandbox="allow-same-origin" onLoad={ajuste} style={{ border: 0, width: "100%", height: 400 }} src={src} />;
// A markdown rendered by the server (report, summary), at the height of its content once its images are loaded
function Page({ title, src }) {
const frame = useRef();
const fit = () => { const b = frame.current?.contentDocument?.body; if (b) frame.current.style.height = `${b.scrollHeight + 20}px`; };
return <iframe ref={frame} title={title} sandbox="allow-same-origin" onLoad={fit} style={{ border: 0, width: "100%", height: 400 }} src={src} />;
}
const COULEUR_ETAT = { "en cours": "blue", fini: "teal", erreur: "red", interrompue: "orange" };
const STATE_COLOR = { running: "blue", done: "teal", error: "red", interrupted: "orange" };
// Une analyse de l'onglet Analysis : son fil (relu toutes les 3 s tant qu'elle travaille), son rapport, et un message à
// l'analyste, qui reprend sa session ; à la fin de chaque tour, les étiquettes se relisent. Une analyse finie s'optimise
// (/detectors:wf-improve sur la plage de l'analyse, puis le tool-builder) : le fil de la séance, puis ses bilans sous le rapport
function Analyse({ nom, sombre, fini, fermer }) {
const [a, setA] = useState(null), [tour, setTour] = useState(0), [texte, setTexte] = useState("");
const boite = useRef(), charge = !!a;
useEffect(() => { if (charge) boite.current?.scrollIntoView({ behavior: "smooth", block: "start" }); }, [nom, charge]); // ouverte : on la voit
// An analysis of the Analysis tab: its thread (read again every 3 s while it works), its report, and a message to the
// analyst, which resumes its session; at the end of each turn, the labels are read again. A finished analysis can be
// optimized (/improve of Optimizer on the range of the analysis, then the tool-builder): the thread of the session, then
// its summaries under the report
function Analysis({ name, dark, done, close }) {
const [a, setA] = useState(null), [turn, setTurn] = useState(0), [text, setText] = useState("");
const box = useRef(), loaded = !!a;
useEffect(() => { if (loaded) box.current?.scrollIntoView({ behavior: "smooth", block: "start" }); }, [name, loaded]); // opened: it is in view
useEffect(() => {
let vivant = true, minuterie;
const lire = () => appel(`/api/analyses/${nom}`).then(r => {
if (!vivant || !r) return;
let alive = true, timer;
const read = () => call(`/api/analyses/${name}`).then(r => {
if (!alive || !r) return;
setA(r);
if (r.etat === "en cours" || r.optimisation?.etat === "en cours") minuterie = setTimeout(lire, 3000);
else if (r.versees !== null) fini();
if (r.state === "running" || r.optimization?.state === "running") timer = setTimeout(read, 3000);
else if (r.submitted !== null) done();
});
lire();
return () => { vivant = false; clearTimeout(minuterie); };
}, [nom, tour]);
async function envoyer() {
if (await appel(`/api/analyses/${nom}/message`, "POST", { texte }) == null) return; // le texte reste dans le champ
setTexte(""); setTour(t => t + 1);
read();
return () => { alive = false; clearTimeout(timer); };
}, [name, turn]);
async function send() {
if (await call(`/api/analyses/${name}/message`, "POST", { text }) == null) return; // the text stays in the field
setText(""); setTurn(t => t + 1);
}
async function optimiser() {
if (await appel(`/api/analyses/${nom}/optimiser`, "POST") != null) setTour(t => t + 1);
async function optimize() {
if (await call(`/api/analyses/${name}/optimize`, "POST") != null) setTurn(t => t + 1);
}
if (!a) return <Loader size="sm" />;
const d = a.demande, o = a.optimisation, occupe = a.etat === "en cours", optimise = o?.etat === "en cours";
const au = new Date(Date.parse(d.fin.slice(0, 10)) + 864e5).toISOString().slice(0, 10);
const d = a.request, o = a.optimization, busy = a.state === "running", optimizing = o?.state === "running";
const end = new Date(Date.parse(d.end.slice(0, 10)) + 864e5).toISOString().slice(0, 10);
return (
<Card withBorder ref={boite}>
<Card withBorder ref={box}>
<Stack gap="xs">
<Group justify="space-between">
<Group gap="xs">
<Title order={5}>Analyse {lisible(d.debut)} → {lisible(d.fin)} UTC</Title>
<Badge color={COULEUR_ETAT[a.etat] || "gray"}>{a.etat}</Badge>
{occupe && <Loader size="xs" />}
<Title order={5}>Analysis {readable(d.start)} → {readable(d.end)} UTC</Title>
<Badge color={STATE_COLOR[a.state] || "gray"}>{a.state}</Badge>
{busy && <Loader size="xs" />}
</Group>
<Group gap="xs">
{a.etat === "fini" && <Tooltip label="Améliorer les détecteurs, puis les outils de lecture, depuis cette analyse (/detectors:wf-improve)">
<Button size="xs" variant="light" onClick={optimiser} disabled={optimise}>Optimiser les détecteurs</Button></Tooltip>}
<ActionIcon variant="subtle" color="gray" aria-label="Fermer le rapport" onClick={fermer}><IconX size={16} /></ActionIcon>
{a.state === "done" && <Tooltip label="Improve the detectors (Optimizer), then the reading tools (tool-builder), from this analysis">
<Button size="xs" variant="light" onClick={optimize} disabled={optimizing}>Optimize the detectors</Button></Tooltip>}
<ActionIcon variant="subtle" color="gray" aria-label="Close the report" onClick={close}><IconX size={16} /></ActionIcon>
</Group>
</Group>
{d.indices && <Text size="sm" c="dimmed">Indices : {d.indices}</Text>}
{a.etat === "interrompue" && <Text size="sm" c="orange">Arrêtée avec le serveur avant la fin.{a.dialogue
? " Sa session est gardée : écrire « continue » ci-dessous pour la reprendre là où elle en était." : ""}</Text>}
{a.versees !== null && a.etat === "fini" && <Text size="sm">{a.versees} étiquette(s) de cette analyse dans labeling/auto/{d.station}.jsonl, à relire.</Text>}
{a.rapport && <Page titre="Rapport" src={`/api/analyses/${nom}/rapport.html?sombre=${sombre}&v=${a.rapport}`} />}
<Fil lignes={a.lignes} />
{d.hints && <Text size="sm" c="dimmed">Hints: {d.hints}</Text>}
{a.state === "interrupted" && <Text size="sm" c="orange">Stopped with the server before the end.{a.dialogue
? " Its session is kept: write “continue” below to resume it where it left off." : ""}</Text>}
{a.submitted !== null && a.state === "done" && <Text size="sm">{a.submitted} label(s) of this analysis in labeling/auto/{d.station}.jsonl, to review.</Text>}
{a.report && <Page title="Report" src={`/api/analyses/${name}/report.html?dark=${dark}&v=${a.report}`} />}
<Thread lines={a.lines} />
{a.dialogue && (
<Group align="flex-end" gap="sm" wrap="nowrap">
<Textarea autosize minRows={1} style={{ flex: 1 }} placeholder="Une question, une correction pour l'analyste"
value={texte} onChange={e => setTexte(e.currentTarget.value)} />
<Button onClick={envoyer} disabled={occupe || optimise || !texte.trim()}>Envoyer</Button>
<Textarea autosize minRows={1} style={{ flex: 1 }} placeholder="A question, a correction for the analyst"
value={text} onChange={e => setText(e.currentTarget.value)} />
<Button onClick={send} disabled={busy || optimizing || !text.trim()}>Send</Button>
</Group>
)}
{o && (
<Stack gap="xs" mt="sm">
<Group gap="xs">
<Title order={5}>Optimisation</Title>
<Badge color={COULEUR_ETAT[o.etat] || "gray"}>{o.etat}</Badge>
{optimise && <Loader size="xs" />}
<Title order={5}>Optimization</Title>
<Badge color={STATE_COLOR[o.state] || "gray"}>{o.state}</Badge>
{optimizing && <Loader size="xs" />}
</Group>
{o.etat === "interrompue" && <Text size="sm" c="orange">Arrêtée avec le serveur ; la relancer par le bouton.</Text>}
<Fil lignes={o.lignes} />
{o.bilan && <Page titre="Bilan" src={`/api/analyses/${nom}/bilan.html?sombre=${sombre}&v=${o.bilan}`} />}
{o.bilan && <Text size="xs" c="dimmed" ff="monospace">python3 detectors/skills/wf-improve/scripts/score.py data/{d.station} --labels labeling/auto/{d.station}.jsonl --from {d.debut.slice(0, 10)} --to {au}</Text>}
{o.state === "interrupted" && <Text size="sm" c="orange">Stopped with the server; rerun it with the button.</Text>}
<Thread lines={o.lines} />
{o.summary && <Page title="Summary" src={`/api/analyses/${name}/summary.html?dark=${dark}&v=${o.summary}`} />}
{o.summary && <Text size="xs" c="dimmed" ff="monospace">python3 detectors/bench/score.py data/{d.station} --labels labeling/auto/{d.station}.jsonl --from {d.start.slice(0, 10)} --to {end}</Text>}
</Stack>
)}
<Text size="xs" c="dimmed">labeling/auto/analyses/{nom}/</Text>
<Text size="xs" c="dimmed">labeling/auto/analyses/{name}/</Text>
</Stack>
</Card>
);
+141 -141
View File
@@ -1,240 +1,240 @@
import { useEffect, useRef, useState } from "react";
import { ActionIcon, Card, Group, Input, Loader, Stack, Text, Tooltip } from "@mantine/core";
import { IconArrowLeft, IconArrowRight, IconChevronLeft, IconChevronRight } from "@tabler/icons-react";
import { appel } from "../commun.jsx";
import { call } from "../common.jsx";
// Les images de la station et de la plage choisies ; compacte : à la largeur d'une colonne (page Data), au format de l'image ;
// basculer : la flèche qui agrandit l'image vers la gauche (large) ou la ramène ; instant {t} : montrer la première image à t ou après
// ({t, proche} : la plus proche de t, avant ou après)
export function ImagesDe({ selection, compacte, large, basculer, instant }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false);
const { station, du, au } = selection;
// The images of the chosen station and range; compact: the width of a column (Data page), in the format of the image;
// toggle: the arrow that enlarges the image to the left (wide) or brings it back; moment {t}: show the first image at t or
// after ({t, nearest}: the nearest to t, before or after)
export function StationImages({ selection, compact, wide, toggle, moment }) {
const [data, setData] = useState(null), [loading, setLoading] = useState(false);
const { station, start, end } = selection;
useEffect(() => {
setDonnees(null);
setData(null);
if (!station) return;
setCharge(true);
appel(`/api/images?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
if (charge) return <Loader />;
if (donnees && !donnees.images.length) return <Text size="sm" c="dimmed">Aucune image de {station} sur cette plage.</Text>;
return donnees && <Visionneuse key={`${station}${du}${au}`} station={station} d={donnees} compacte={compacte} large={large} basculer={basculer} instant={instant} />;
setLoading(true);
call(`/api/images?${new URLSearchParams({ station, start, end })}`).then(d => { setData(d); setLoading(false); });
}, [station, start, end]);
if (loading) return <Loader />;
if (data && !data.images.length) return <Text size="sm" c="dimmed">No image of {station} in this range.</Text>;
return data && <Viewer key={`${station}${start}${end}`} station={station} d={data} compact={compact} wide={wide} toggle={toggle} moment={moment} />;
}
function Visionneuse({ station, d, compacte, large, basculer, instant }) {
const r = { cadre: useRef(), couche: useRef(), img: useRef(), marques: useRef(), vecteurs: useRef(), glis: useRef(),
heure: useRef(), noms: useRef(), barre: useRef(), bande: useRef(), plage: useRef(), echelle: useRef(),
prec: useRef(), suiv: useRef(), montre: useRef() };
const XY = d.positions, refs = new Set(d.references), avecPositions = Object.keys(XY).length > 0;
function Viewer({ station, d, compact, wide, toggle, moment }) {
const r = { frame: useRef(), layer: useRef(), img: useRef(), marks: useRef(), vectors: useRef(), slider: useRef(),
time: useRef(), names: useRef(), bar: useRef(), band: useRef(), range: useRef(), scale: useRef(),
prev: useRef(), next: useRef(), show: useRef() };
const XY = d.positions, refs = new Set(d.references), withPositions = Object.keys(XY).length > 0;
useEffect(() => installer(r, station, d), [d]);
useEffect(() => { // « AAAA-MM-JJTHH:MMZ » face aux heures des images, « AAAA-MM-JJ HH:MM » (UTC)
if (!instant) return;
const t = instant.t.slice(0, 16).replace("T", " "), i = d.images.findIndex(im => im.t >= t);
const ms = s => Date.parse(s.slice(0, 16).replace(" ", "T") + "Z"), ecart = j => Math.abs(ms(d.images[j].t) - ms(t));
if (instant.proche && i !== 0) r.montre.current(i < 0 || ecart(i - 1) <= ecart(i) ? (i < 0 ? d.images.length : i) - 1 : i);
else r.montre.current(i < 0 ? d.images.length - 1 : i);
}, [instant, d]);
useEffect(() => install(r, station, d), [d]);
useEffect(() => { // "YYYY-MM-DDTHH:MMZ" against the times of the images, "YYYY-MM-DD HH:MM" (UTC)
if (!moment) return;
const t = moment.t.slice(0, 16).replace("T", " "), i = d.images.findIndex(im => im.t >= t);
const ms = s => Date.parse(s.slice(0, 16).replace(" ", "T") + "Z"), gap = j => Math.abs(ms(d.images[j].t) - ms(t));
if (moment.nearest && i !== 0) r.show.current(i < 0 || gap(i - 1) <= gap(i) ? (i < 0 ? d.images.length : i) - 1 : i);
else r.show.current(i < 0 ? d.images.length - 1 : i);
}, [moment, d]);
return (
<Card shadow="sm" withBorder padding={0} className="visionneuse">
{basculer && (
<Tooltip label={large ? "Réduire l'image" : "Agrandir l'image"}>
<ActionIcon className="agrandir" variant="filled" color="dark" aria-label={large ? "Réduire l'image" : "Agrandir l'image"} onClick={basculer}>
{large ? <IconArrowRight size={18} /> : <IconArrowLeft size={18} />}
<Card shadow="sm" withBorder padding={0} className="viewer">
{toggle && (
<Tooltip label={wide ? "Shrink the image" : "Enlarge the image"}>
<ActionIcon className="enlarge" variant="filled" color="dark" aria-label={wide ? "Shrink the image" : "Enlarge the image"} onClick={toggle}>
{wide ? <IconArrowRight size={18} /> : <IconArrowLeft size={18} />}
</ActionIcon>
</Tooltip>
)}
<div className={compacte ? "cadre compacte" : "cadre"} ref={r.cadre}>
<div className="couche" ref={r.couche}>
<div className={compact ? "frame compact" : "frame"} ref={r.frame}>
<div className="layer" ref={r.layer}>
<img ref={r.img} alt="" draggable="false" />
<svg className="marques" ref={r.marques} style={{ display: "none" }}>
<svg className="marks" ref={r.marks} style={{ display: "none" }}>
{Object.entries(XY).map(([s, [x, y]]) => (
<g key={s} className={refs.has(s) ? "ref" : "cible"}>
<g key={s} className={refs.has(s) ? "ref" : "target"}>
<circle cx={x} cy={y} r=".7em" /><text x={x} y={y} dy="-1em">{s}</text>
</g>
))}
</svg>
<svg className="vecteurs" ref={r.vecteurs} style={{ display: "none" }}>
<defs><marker id="pointe" viewBox="0 0 10 14" refX="9" refY="7" markerWidth="5" markerHeight="7" orient="auto">
<svg className="vectors" ref={r.vectors} style={{ display: "none" }}>
<defs><marker id="arrowhead" viewBox="0 0 10 14" refX="9" refY="7" markerWidth="5" markerHeight="7" orient="auto">
<path d="M0,0 L10,7 L0,14 z" fill="#2ecc40" /></marker></defs>
</svg>
</div>
</div>
<Stack gap={6} p="md">
<Group gap="sm" wrap="nowrap">
<ActionIcon ref={r.prec} variant="light" aria-label="Image précédente"><IconChevronLeft size={18} /></ActionIcon>
<input ref={r.glis} className="glisseur" type="range" min="0" max={d.images.length - 1} defaultValue="0" />
<ActionIcon ref={r.suiv} variant="light" aria-label="Image suivante"><IconChevronRight size={18} /></ActionIcon>
<ActionIcon ref={r.prev} variant="light" aria-label="Previous image"><IconChevronLeft size={18} /></ActionIcon>
<input ref={r.slider} className="slider" type="range" min="0" max={d.images.length - 1} defaultValue="0" />
<ActionIcon ref={r.next} variant="light" aria-label="Next image"><IconChevronRight size={18} /></ActionIcon>
</Group>
<div className="barre-plages" ref={r.barre}><div className="bande" ref={r.bande} style={{ display: "none" }} /></div>
<div className="range-bar" ref={r.bar}><div className="band" ref={r.band} style={{ display: "none" }} /></div>
<Group gap="lg" justify="space-between">
<Text ref={r.heure} ff="monospace" size="sm" />
<Text ref={r.time} ff="monospace" size="sm" />
<Group gap="md">
<label className="case"><input type="checkbox" ref={r.noms} disabled={!avecPositions} /> Noms</label>
{avecPositions
? <span className="legende"><span className="cible">○ Cible</span> <span className="ref">◌ Référence</span></span>
: <Text size="sm" c="dimmed">x, y ne sont pas des positions dans l'image sur cette station</Text>}
<label className="check"><input type="checkbox" ref={r.names} disabled={!withPositions} /> Names</label>
{withPositions
? <span className="legend"><span className="target">○ Target</span> <span className="ref">◌ Reference</span></span>
: <Text size="sm" c="dimmed">x, y are not positions in the image on this station</Text>}
</Group>
</Group>
<Group gap="lg" justify="space-between">
<Text ref={r.plage} size="sm" />
<Text ref={r.range} size="sm" />
<Group gap="xs" wrap="nowrap">
<Text size="sm">Flèches ×</Text>
<Input ref={r.echelle} type="number" min={1} defaultValue={100} w={90} size="xs" />
<Text size="sm">Arrows ×</Text>
<Input ref={r.scale} type="number" min={1} defaultValue={100} w={90} size="xs" />
</Group>
</Group>
<Text size="xs" c="dimmed">← → image · molette : zoom · glisser : se déplacer · double clic : image entière · flèche :
corr_x, corr_y à la fin moins au début (px), dans les axes de l'image</Text>
<Text size="xs" c="dimmed">← → image · wheel: zoom · drag: move · double click: whole image · arrow:
corr_x, corr_y at the end minus at the start (px), in the axes of the image</Text>
</Stack>
</Card>
);
}
// 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)}` }));
// The behaviour of the image (zoom, move, arrows), on the elements of the page -> the function that undoes what it installed
function install(r, station, d) {
const IM = d.images.map(i => ({ t: i.t, src: `/api/image/${encodeURIComponent(station)}/${encodeURIComponent(i.name)}` }));
const C = d.corr, XY = d.positions;
const cadre = r.cadre.current, couche = r.couche.current, img = r.img.current, glis = r.glis.current, heure = r.heure.current;
const marques = r.marques.current, vecteurs = r.vecteurs.current, labels = r.noms.current;
const barre = r.barre.current, bande = r.bande.current, plage = r.plage.current, echelle = r.echelle.current;
const frame = r.frame.current, layer = r.layer.current, img = r.img.current, slider = r.slider.current, time = r.time.current;
const marks = r.marks.current, vectors = r.vectors.current, labels = r.names.current;
const bar = r.bar.current, band = r.band.current, range = r.range.current, scale = r.scale.current;
let V = 0, Z = { k: 1, x: 0, y: 0 }, P = null;
function zoom() {
Z.x = Math.min(0, Math.max(1 - Z.k, Z.x)); // l'image couvre toujours le cadre : on ne la perd pas en la glissant
Z.x = Math.min(0, Math.max(1 - Z.k, Z.x)); // the image always covers the frame: it is not lost by dragging it
Z.y = Math.min(0, Math.max(1 - Z.k, Z.y));
couche.style.transform = `translate(${Z.x * 100}%, ${Z.y * 100}%) scale(${Z.k})`;
// Les noms restent à 12 px à l'écran : les tailles des marques sont en em, et 1 px du svg vaut 1 px de l'image.
layer.style.transform = `translate(${Z.x * 100}%, ${Z.y * 100}%) scale(${Z.k})`;
// The names stay at 12 px on screen: the sizes of the marks are in em, and 1 px of the svg is 1 px of the image.
const W = img.naturalWidth, H = img.naturalHeight;
if (W) marques.style.fontSize = vecteurs.style.fontSize = `${12 / (Z.k * Math.min(cadre.clientWidth / W, cadre.clientHeight / H))}px`;
cale();
if (W) marks.style.fontSize = vectors.style.fontSize = `${12 / (Z.k * Math.min(frame.clientWidth / W, frame.clientHeight / H))}px`;
align();
}
const affiche = () => { marques.style.display = labels.checked && img.naturalWidth ? "" : "none"; };
labels.onchange = affiche;
r.montre.current = i => montre(i); // pour la page Data : l'image du début d'un événement
const display = () => { marks.style.display = labels.checked && img.naturalWidth ? "" : "none"; };
labels.onchange = display;
r.show.current = i => show(i); // for the Data page: the image of the start of an event
function montre(i) {
function show(i) {
V = Math.max(0, Math.min(IM.length - 1, i));
glis.value = V;
slider.value = V;
img.src = IM[V].src;
for (const n of [V - 1, V + 1]) if (IM[n]) new Image().src = IM[n].src; // les voisines, en cache
for (const n of [V - 1, V + 1]) if (IM[n]) new Image().src = IM[n].src; // the neighbours, in cache
}
// L'heure change avec l'image, pas avant : l'image d'avant reste affichée tant que la nouvelle se charge.
// The time changes with the image, not before: the previous image stays shown while the new one loads.
img.onload = () => {
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length})`;
marques.setAttribute("viewBox", `0 0 ${img.naturalWidth} ${img.naturalHeight}`); // cadré comme l'image, object-fit: contain
vecteurs.setAttribute("viewBox", marques.getAttribute("viewBox"));
fleches(); zoom(); affiche();
time.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length})`;
marks.setAttribute("viewBox", `0 0 ${img.naturalWidth} ${img.naturalHeight}`); // framed as the image, object-fit: contain
vectors.setAttribute("viewBox", marks.getAttribute("viewBox"));
arrows(); zoom(); display();
};
img.onerror = () => {
img.removeAttribute("src");
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length}) : image illisible`;
affiche();
time.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length}): unreadable image`;
display();
};
glis.oninput = () => montre(+glis.value);
r.prec.current.onclick = () => montre(V - 1);
r.suiv.current.onclick = () => montre(V + 1);
const clavier = e => {
if (!glis.offsetParent // la page Data cachée (une autre page affichée) : les flèches ne sont pas pour elle
slider.oninput = () => show(+slider.value);
r.prev.current.onclick = () => show(V - 1);
r.next.current.onclick = () => show(V + 1);
const keyboard = e => {
if (!slider.offsetParent // the Data page hidden (another page shown): the arrows are not for it
|| e.target.matches("textarea, select, input:not([type=range])") || !["ArrowLeft", "ArrowRight"].includes(e.key)) return;
e.preventDefault(); // sinon le glisseur, s'il a le focus, avance une seconde fois
montre(V + (e.key === "ArrowLeft" ? -1 : 1));
e.preventDefault(); // otherwise the slider, if it has the focus, moves a second time
show(V + (e.key === "ArrowLeft" ? -1 : 1));
};
document.addEventListener("keydown", clavier);
document.addEventListener("keydown", keyboard);
const molette = ev => { // zoom autour du pointeur
const wheel = ev => { // zoom around the pointer
ev.preventDefault();
const b = cadre.getBoundingClientRect(), u = (ev.clientX - b.left) / b.width, v = (ev.clientY - b.top) / b.height;
const b = frame.getBoundingClientRect(), u = (ev.clientX - b.left) / b.width, v = (ev.clientY - b.top) / b.height;
const k = Math.min(40, Math.max(1, Z.k * Math.exp(-ev.deltaY / 500)));
Z = { k, x: u - k * (u - Z.x) / Z.k, y: v - k * (v - Z.y) / Z.k };
zoom();
};
cadre.addEventListener("wheel", molette, { passive: false });
cadre.onpointerdown = ev => { // déplacement à la souris
cadre.setPointerCapture(ev.pointerId);
const b = cadre.getBoundingClientRect(), de = { ...Z, cx: ev.clientX, cy: ev.clientY };
cadre.onpointermove = e => { Z.x = de.x + (e.clientX - de.cx) / b.width; Z.y = de.y + (e.clientY - de.cy) / b.height; zoom(); };
cadre.onpointerup = () => { cadre.onpointermove = null; };
frame.addEventListener("wheel", wheel, { passive: false });
frame.onpointerdown = ev => { // move with the mouse
frame.setPointerCapture(ev.pointerId);
const b = frame.getBoundingClientRect(), from = { ...Z, cx: ev.clientX, cy: ev.clientY };
frame.onpointermove = e => { Z.x = from.x + (e.clientX - from.cx) / b.width; Z.y = from.y + (e.clientY - from.cy) / b.height; zoom(); };
frame.onpointerup = () => { frame.onpointermove = null; };
};
cadre.ondblclick = () => { Z = { k: 1, x: 0, y: 0 }; zoom(); };
frame.ondblclick = () => { Z = { k: 1, x: 0, y: 0 }; zoom(); };
// La plage : glisser sur la barre, alignée sur le glisseur ; les flèches vont de la position du capteur à position + k × déplacement.
function cale() {
const g = glis.getBoundingClientRect(), b = barre.getBoundingClientRect();
barre.style.marginLeft = `${(parseFloat(barre.style.marginLeft) || 0) + g.left - b.left}px`; barre.style.width = `${g.width}px`;
// The range: drag on the bar, aligned with the slider; the arrows go from the position of the sensor to position + k × displacement.
function align() {
const g = slider.getBoundingClientRect(), b = bar.getBoundingClientRect();
bar.style.marginLeft = `${(parseFloat(bar.style.marginLeft) || 0) + g.left - b.left}px`; bar.style.width = `${g.width}px`;
}
const indice = ev => { const b = barre.getBoundingClientRect(); return Math.round(Math.max(0, Math.min(1, (ev.clientX - b.left) / b.width)) * (IM.length - 1)); };
function bandeau() {
const index = ev => { const b = bar.getBoundingClientRect(); return Math.round(Math.max(0, Math.min(1, (ev.clientX - b.left) / b.width)) * (IM.length - 1)); };
function drawBand() {
const n = Math.max(1, IM.length - 1), [i, j] = P ? [Math.min(...P), Math.max(...P)] : [0, 0];
bande.style.left = `${i / n * 100}%`; bande.style.width = `${(j - i) / n * 100}%`; bande.style.display = P ? "" : "none";
band.style.left = `${i / n * 100}%`; band.style.width = `${(j - i) / n * 100}%`; band.style.display = P ? "" : "none";
}
function deplacements() {
function displacements() {
if (!P || P[0] === P[1]) return {};
const [i, j] = [Math.min(...P), Math.max(...P)], dep = {};
for (const [s, c] of Object.entries(C)) if (c[i] && c[j]) dep[s] = [c[j][0] - c[i][0], c[j][1] - c[i][1]];
return dep;
}
function fleches() {
const dep = deplacements(), W = img.naturalWidth, k = +echelle.value;
vecteurs.style.display = Object.keys(dep).length && W ? "" : "none";
vecteurs.querySelectorAll("line").forEach(l => l.remove());
function arrows() {
const dep = displacements(), W = img.naturalWidth, k = +scale.value;
vectors.style.display = Object.keys(dep).length && W ? "" : "none";
vectors.querySelectorAll("line").forEach(l => l.remove());
for (const [s, [dx, dy]] of Object.entries(dep)) {
const [x, y] = XY[s], l = document.createElementNS("http://www.w3.org/2000/svg", "line");
Object.entries({ x1: x, y1: y, x2: x + k * dx, y2: y + k * dy }).forEach(([a, v]) => l.setAttribute(a, v));
const titre = document.createElementNS("http://www.w3.org/2000/svg", "title");
titre.textContent = `${s} : corr_x ${dx.toFixed(3)} px, corr_y ${dy.toFixed(3)} px`;
l.appendChild(titre);
vecteurs.appendChild(l);
const title = document.createElementNS("http://www.w3.org/2000/svg", "title");
title.textContent = `${s}: corr_x ${dx.toFixed(3)} px, corr_y ${dy.toFixed(3)} px`;
l.appendChild(title);
vectors.appendChild(l);
}
if (P && P[0] !== P[1]) {
const [i, j] = [Math.min(...P), Math.max(...P)], manque = Object.keys(C).filter(s => !(s in dep));
plage.textContent = `${IM[i].t} → ${IM[j].t} UTC` + (manque.length ? ` · pas de mesure valide à une borne : ${manque.join(", ")}` : "");
} else plage.textContent = Object.keys(C).length ? "Glisser sur la barre pour choisir une plage" : "Pas de flèches : x, y ne sont pas des positions dans l'image";
const [i, j] = [Math.min(...P), Math.max(...P)], missing = Object.keys(C).filter(s => !(s in dep));
range.textContent = `${IM[i].t} → ${IM[j].t} UTC` + (missing.length ? ` · no valid measurement at a bound: ${missing.join(", ")}` : "");
} else range.textContent = Object.keys(C).length ? "Drag on the bar to choose a range" : "No arrows: x, y are not positions in the image";
}
// Ce que saisit le pointeur sur une plage placée : 0 son début, 1 sa fin (à 6 px près), 2 la bande entière, null rien.
function prise(ev) {
// What the pointer grabs on a placed range: 0 its start, 1 its end (within 6 px), 2 the whole band, null nothing.
function grab(ev) {
if (!P) return null;
const x = ev.clientX - barre.getBoundingClientRect().left, px = i => i / Math.max(1, IM.length - 1) * barre.clientWidth;
const x = ev.clientX - bar.getBoundingClientRect().left, px = i => i / Math.max(1, IM.length - 1) * bar.clientWidth;
return Math.abs(x - px(P[0])) < 6 ? 0 : Math.abs(x - px(P[1])) < 6 ? 1 : x > px(P[0]) && x < px(P[1]) ? 2 : null;
}
barre.onpointermove = e => {
if (!barre.hasPointerCapture(e.pointerId)) barre.style.cursor = ["ew-resize", "ew-resize", "grab"][prise(e)] || "crosshair";
bar.onpointermove = e => {
if (!bar.hasPointerCapture(e.pointerId)) bar.style.cursor = ["ew-resize", "ew-resize", "grab"][grab(e)] || "crosshair";
};
barre.onpointerdown = ev => {
barre.setPointerCapture(ev.pointerId);
const g = prise(ev), i0 = indice(ev), de = P && [...P];
bar.onpointerdown = ev => {
bar.setPointerCapture(ev.pointerId);
const g = grab(ev), i0 = index(ev), from = P && [...P];
if (g === null) P = [i0, i0];
bandeau(); montre(i0);
const survol = barre.onpointermove;
barre.onpointermove = e => {
const i = indice(e);
if (g === 2) { // la bande glisse sans sortir de la barre
const dd = Math.max(-de[0], Math.min(IM.length - 1 - de[1], i - i0));
P = [de[0] + dd, de[1] + dd];
drawBand(); show(i0);
const hover = bar.onpointermove;
bar.onpointermove = e => {
const i = index(e);
if (g === 2) { // the band slides without leaving the bar
const dd = Math.max(-from[0], Math.min(IM.length - 1 - from[1], i - i0));
P = [from[0] + dd, from[1] + dd];
} else P[g === null ? 1 : g] = i;
bandeau(); fleches(); montre(i);
drawBand(); arrows(); show(i);
};
barre.onpointerup = () => {
barre.onpointermove = survol;
bar.onpointerup = () => {
bar.onpointermove = hover;
P = [Math.min(...P), Math.max(...P)];
if (P[0] === P[1]) P = null;
else if (g === null) { // nouvelle plage, facteur proposé : la plus grande flèche fait 8 % de la largeur de l'image
const m = Math.max(...Object.values(deplacements()).map(([a, b]) => Math.hypot(a, b)), 0);
if (m && img.naturalWidth) echelle.value = Math.max(1, Math.round(0.08 * img.naturalWidth / m));
else if (g === null) { // new range, proposed factor: the largest arrow is 8 % of the width of the image
const m = Math.max(...Object.values(displacements()).map(([a, b]) => Math.hypot(a, b)), 0);
if (m && img.naturalWidth) scale.value = Math.max(1, Math.round(0.08 * img.naturalWidth / m));
}
bandeau(); fleches();
drawBand(); arrows();
};
};
echelle.oninput = fleches;
scale.oninput = arrows;
addEventListener("resize", zoom);
const observateur = new ResizeObserver(zoom); // la barre latérale qui se replie change la largeur sans resize
observateur.observe(cadre);
const observer = new ResizeObserver(zoom); // the sidebar that folds changes the width without resize
observer.observe(frame);
montre(0); cale(); fleches();
show(0); align(); arrows();
return () => {
document.removeEventListener("keydown", clavier);
document.removeEventListener("keydown", keyboard);
removeEventListener("resize", zoom);
cadre.removeEventListener("wheel", molette);
observateur.disconnect();
frame.removeEventListener("wheel", wheel);
observer.disconnect();
};
}
+29 -35
View File
@@ -1,39 +1,33 @@
/* Le reste du visuel vient de Mantine (thème dans main.jsx) */
.entete { background: #3d4977; color: #fff; border-bottom: 0; }
.message { white-space: pre-wrap; overflow-wrap: anywhere; }
.message.support, .message.relai { background: var(--mantine-color-aimsight-light); }
.message.analyste { background: var(--mantine-color-teal-light); }
.message.marc { background: var(--mantine-color-yellow-light); align-self: flex-end; max-width: 85%; }
.message.relai { border-left: 3px solid var(--mantine-color-aimsight-filled); }
.rapport { width: 100%; height: 78vh; border: 0; display: block; background: #fff; }
/* The rest of the visuals comes from Mantine (theme in main.jsx) */
.header { background: #3d4977; color: #fff; border-bottom: 0; }
/* Les images de la caméra (Images.jsx) */
.cadre { position: relative; height: calc(100vh - 420px); min-height: 300px; background: #000; overflow: hidden; cursor: grab;
/* The camera images (Images.jsx) */
.frame { 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; }
.cadre.compacte { height: auto; min-height: 0; aspect-ratio: 3 / 2; } /* page Data : la colonne de droite */
.couche { position: absolute; inset: 0; transform-origin: 0 0; }
.couche > * { position: absolute; inset: 0; width: 100%; height: 100%; }
.couche img { object-fit: contain; user-select: none; }
.marques { overflow: visible; pointer-events: none; font-family: sans-serif; }
.marques circle { fill: none; stroke: currentColor; stroke-width: .12em; }
.marques .ref circle { stroke-dasharray: .3em .2em; }
.marques text { fill: currentColor; text-anchor: middle; paint-order: stroke; stroke: rgba(0, 0, 0, .85); stroke-width: .25em; stroke-linejoin: round; }
.cible { color: #ffd400; } .ref { color: #3cc8ff; }
.legende { background: #000; padding: 2px 8px; border-radius: 3px; white-space: nowrap; font-size: var(--mantine-font-size-sm); }
.vecteurs { overflow: visible; pointer-events: none; }
.vecteurs line { stroke: #2ecc40; stroke-width: .18em; marker-end: url(#pointe); }
.glisseur { flex: 1; min-width: 0; accent-color: var(--mantine-primary-color-filled); }
.barre-plages { position: relative; height: 22px; background: var(--mantine-color-default-hover); border: 1px solid var(--mantine-color-default-border);
border-radius: 3px; cursor: crosshair; touch-action: none; }
.bande { position: absolute; top: 0; bottom: 0; background: #e0730080; border-left: 2px solid #e07300; border-right: 2px solid #e07300; }
.case { display: flex; gap: 6px; align-items: center; font-size: var(--mantine-font-size-sm); }
/* page Data : le menu d'un plot dans sa marge du haut ; les images restent en vue quand on fait défiler les plots */
.frame:active { cursor: grabbing; }
.frame.compact { height: auto; min-height: 0; aspect-ratio: 3 / 2; } /* Data page: the right column */
.layer { position: absolute; inset: 0; transform-origin: 0 0; }
.layer > * { position: absolute; inset: 0; width: 100%; height: 100%; }
.layer img { object-fit: contain; user-select: none; }
.marks { overflow: visible; pointer-events: none; font-family: sans-serif; }
.marks circle { fill: none; stroke: currentColor; stroke-width: .12em; }
.marks .ref circle { stroke-dasharray: .3em .2em; }
.marks text { fill: currentColor; text-anchor: middle; paint-order: stroke; stroke: rgba(0, 0, 0, .85); stroke-width: .25em; stroke-linejoin: round; }
.target { color: #ffd400; } .ref { color: #3cc8ff; }
.legend { background: #000; padding: 2px 8px; border-radius: 3px; white-space: nowrap; font-size: var(--mantine-font-size-sm); }
.vectors { overflow: visible; pointer-events: none; }
.vectors line { stroke: #2ecc40; stroke-width: .18em; marker-end: url(#arrowhead); }
.slider { flex: 1; min-width: 0; accent-color: var(--mantine-primary-color-filled); }
.range-bar { position: relative; height: 22px; background: var(--mantine-color-default-hover); border: 1px solid var(--mantine-color-default-border);
border-radius: 3px; cursor: crosshair; touch-action: none; }
.band { position: absolute; top: 0; bottom: 0; background: #e0730080; border-left: 2px solid #e07300; border-right: 2px solid #e07300; }
.check { display: flex; gap: 6px; align-items: center; font-size: var(--mantine-font-size-sm); }
/* Data page: the menu of a plot in its top margin; the images stay in view when the plots scroll */
.plot { position: relative; }
.plot-menu { position: absolute; top: 2px; left: 56px; z-index: 2; }
.colle { position: sticky; top: calc(64px + var(--mantine-spacing-lg)); }
/* page Data : la flèche qui agrandit l'image, en haut à gauche de l'image (du côté des plots qu'elle pousse) */
.visionneuse { position: relative; }
.agrandir { position: absolute; top: 8px; left: 8px; z-index: 3; opacity: .75; }
.agrandir:hover { opacity: 1; }
.data-grille .mantine-Grid-col { transition: flex-basis .35s ease, max-width .35s ease; min-width: 0; } /* l'image qui grandit pousse les plots */
.sticky { position: sticky; top: calc(64px + var(--mantine-spacing-lg)); }
/* Data page: the arrow that enlarges the image, at the top left of the image (on the side of the plots it pushes) */
.viewer { position: relative; }
.enlarge { position: absolute; top: 8px; left: 8px; z-index: 3; opacity: .75; }
.enlarge:hover { opacity: 1; }
.data-grid .mantine-Grid-col { transition: flex-basis .35s ease, max-width .35s ease; min-width: 0; } /* the image that grows pushes the plots */
+1 -1
View File
@@ -1,7 +1,7 @@
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
// npm run dev : la page sur http://localhost:5173, l'API demandée au serveur Python (port 8770)
// npm run dev: the page on http://localhost:5173, the API asked of the Python server (port 8770)
export default defineConfig({
plugins: [react()],
server: { proxy: { "/api": "http://127.0.0.1:8770" } },
Submodule detectors deleted from 21a35d90aa.
+344
View File
@@ -0,0 +1,344 @@
<mxfile host="Electron" pages="2">
<diagram name="1. Dépôts" id="dep">
<mxGraphModel dx="4158" dy="2560" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1720" pageHeight="1110" math="0" shadow="0">
<root>
<mxCell id="0" />
<mxCell id="1" parent="0" />
<mxCell id="plat" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b&gt;Plateforme AIMsight&lt;/b&gt;&lt;br&gt;base et S3 de l&#39;appli" vertex="1">
<mxGeometry height="60" width="150" y="-260" as="geometry" />
</mxCell>
<mxCell id="expert" parent="1" style="shape=umlActor;verticalLabelPosition=bottom;verticalAlign=top;html=1;fontSize=12;" value="L&#39;expert" vertex="1">
<mxGeometry height="55" width="30" x="800" y="-130" as="geometry" />
</mxCell>
<mxCell id="app" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b style=&quot;font-size:14px&quot;&gt;Diagnostic-App&lt;/b&gt;&lt;br&gt;&lt;i&gt;le poste de pilotage : voir, analyser, lancer&lt;/i&gt;&lt;br&gt;• app/ : serveur FastAPI, page Data (courbes, images, étiquettes, événements des détecteurs), onglet Analysis&lt;br&gt;• boutons « Analyser la plage », « Optimiser les détecteurs » : ils lancent des processus dont le code vit ailleurs&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; consignes/analyste.md : ce que l&#39;app demande à l&#39;analyste (dossier de sortie, rapport, dialogue)&lt;br&gt;&lt;font color=&quot;#c62828&quot;&gt;&lt;b&gt;→&lt;/b&gt;&lt;/font&gt; agent-tools/ et le skill lire-les-donnees (vers tools) ; analyste et tool-builder (vers agents)" vertex="1">
<mxGeometry height="110" width="610" x="510" y="70" as="geometry" />
</mxCell>
<mxCell id="agents" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b style=&quot;font-size:14px&quot;&gt;agents&lt;/b&gt;&lt;br&gt;&lt;i&gt;les agents génériques, un seul exemplaire de chacun&lt;/i&gt;&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; analyste : DETECTEURS oui/non, CONSIGNES (le fichier de l&#39;appelant)&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; tool-builder (de Diagnostic-App)&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; upgrader, validator (de detectors)&lt;br&gt;• un plugin Claude Code, chargé en lecture ; l&#39;appelant passe ses paramètres dans la requête&lt;br&gt;• Claude n&#39;écrit pas dans un plugin chargé : ce qui s&#39;écrit (outils, détecteurs, séances) vit ailleurs" vertex="1">
<mxGeometry height="130" width="540" x="-325" y="450" as="geometry" />
</mxCell>
<mxCell id="opt" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b style=&quot;font-size:14px&quot;&gt;Optimizer&lt;/b&gt;&lt;br&gt;&lt;i&gt;l&#39;optimisation des détecteurs, sur les étiquettes de labeling/auto&lt;/i&gt;&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; .claude/skills/improve/ : l&#39;orchestrateur (ex wf-improve de detectors)&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; seances/&amp;lt;analyse&amp;gt;_&amp;lt;heure&amp;gt;/ : mesures, modification, validation, bilan&lt;br&gt;• lancé par l&#39;app ou à la main&lt;br&gt;&lt;font color=&quot;#c62828&quot;&gt;&lt;b&gt;→&lt;/b&gt;&lt;/font&gt; archive/ : batch.py, scanner, batches/, outils/, essais et leur spec : l&#39;auto-étiquetage par les détecteurs, arrêté" vertex="1">
<mxGeometry height="130" width="440" x="510" y="660" as="geometry" />
</mxCell>
<mxCell id="data" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b style=&quot;font-size:14px&quot;&gt;aimsight-data&lt;/b&gt;&lt;br&gt;&lt;i&gt;les données : les pomper&lt;/i&gt;&lt;br&gt;• data/&amp;lt;STATION&amp;gt;/ : les mesures et les images (hors de git)&lt;br&gt;• extraction/ : le pompage, chaque nuit" vertex="1">
<mxGeometry height="95" width="590" x="-220" y="-80" as="geometry" />
</mxCell>
<mxCell id="tools" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#b0e3e6;strokeColor=#0e8088;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b style=&quot;font-size:14px&quot;&gt;tools&lt;/b&gt; (nouveau)&lt;br&gt;&lt;i&gt;le harnais de lecture : les méthodes données à l&#39;agent pour appréhender les données&lt;/i&gt;&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; les outils (de Diagnostic-App agent-tools/) : inventaire, resume, plages, jours, ensemble, metriques, qualite, stations, graphique, vignettes, gif&lt;br&gt;&lt;font color=&quot;#2e7d32&quot;&gt;&lt;b&gt;+&lt;/b&gt;&lt;/font&gt; donnees.py, la lecture commune (aussi pour l&#39;app) ; le guide, quel outil pour quelle question (ex skill lire-les-donnees)&lt;br&gt;• seul le tool-builder y écrit : il optimise ou ajoute, ne retire rien" vertex="1">
<mxGeometry height="165" width="470" x="-350" y="160" as="geometry" />
</mxCell>
<mxCell id="dep-t1" edge="1" parent="1" source="tools" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.398;entryY=1;entryDx=0;entryDy=0;" target="data" value="lit data/">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="dep-t2" edge="1" parent="1" source="app" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;" target="tools" value="importe donnees.py">
<mxGeometry relative="1" x="0.1383" as="geometry">
<Array as="points">
<mxPoint x="540.5" y="240" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="lab" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b style=&quot;font-size:14px&quot;&gt;labeling&lt;/b&gt; — inchangé&lt;br&gt;&lt;i&gt;la vérité : les étiquettes et le savoir pour les poser&lt;/i&gt;&lt;br&gt;• manual/ : l&#39;expert ; auto/ : les agents, la vérité de l&#39;entraînement des détecteurs&lt;br&gt;• auto/analyses/ : les analyses de l&#39;app (rapport, étiquettes, scripts)&lt;br&gt;• familles, règles d&#39;étiquetage, carte des étiquettes, connaissances&lt;br&gt;• controle.py, ids.py, precedents.py (le RAG, par Ollama)" vertex="1">
<mxGeometry height="110" width="460" x="500" y="460" as="geometry" />
</mxCell>
<mxCell id="det" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b style=&quot;font-size:14px&quot;&gt;detectors&lt;/b&gt;&lt;br&gt;&lt;i&gt;les détecteurs et leur benchmark&lt;/i&gt;&lt;br&gt;• scripts/ : un détecteur par famille, categories.py, data.py&lt;br&gt;• thresholds.md ; contrat lu par l&#39;app et l&#39;Optimizer : categories.events, data.py&lt;br&gt;• bench/ : score.py, regression.py, sensors.py (ex skills/wf-improve/scripts/)&lt;br&gt;&lt;font color=&quot;#c62828&quot;&gt;&lt;b&gt;→&lt;/b&gt;&lt;/font&gt; le plugin wf-improve : le skill vers Optimizer, les agents vers agents ; plus de plugin ici" vertex="1">
<mxGeometry height="120" width="440" x="1240" y="665" as="geometry" />
</mxCell>
<mxCell id="dep-e1" edge="1" parent="1" source="expert" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;" target="app" value="">
<mxGeometry relative="1" x="-0.0318" as="geometry" />
</mxCell>
<mxCell id="dep-e2" edge="1" parent="1" source="plat" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;" target="data" value="pompage, lecture seule">
<mxGeometry relative="1" x="-0.0857" as="geometry">
<mxPoint as="offset" />
<Array as="points" />
</mxGeometry>
</mxCell>
<mxCell id="dep-e3" edge="1" parent="1" source="app" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=classic;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;startArrow=none;startFill=0;" target="data" value="lit : données">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="dep-e4" edge="1" parent="1" source="app" style="rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;edgeStyle=orthogonalEdgeStyle;" target="agents" value="lance l&#39;analyste, le tool-builder">
<mxGeometry relative="1" x="-0.0392" y="-15" as="geometry">
<mxPoint as="offset" />
<Array as="points">
<mxPoint x="680" y="428" />
<mxPoint x="180" y="428" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="dep-e5" edge="1" parent="1" source="app" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;" target="lab" value="lit et écrit : étiquettes&lt;br&gt;de l&#39;expert, analyses">
<mxGeometry relative="1" x="0.0036" as="geometry">
<Array as="points">
<mxPoint x="815" y="400" />
<mxPoint x="815" y="400" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="dep-e6" edge="1" parent="1" source="app" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;" target="opt" value="lance l&#39;optimisation">
<mxGeometry relative="1" x="0.2034" as="geometry">
<Array as="points">
<mxPoint x="1050" y="695" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="dep-e7" edge="1" parent="1" source="app" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;" target="det" value="lit : événements des détecteurs">
<mxGeometry relative="1" x="-0.0172" as="geometry">
<Array as="points">
<mxPoint x="1500" y="125" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="dep-e8" edge="1" parent="1" source="opt" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=none;endFill=0;fontSize=11;labelBackgroundColor=#ffffff;" target="agents" value="lance l&#39;upgrader,&lt;br&gt;le validator">
<mxGeometry relative="1" x="-0.2105" y="-15" as="geometry">
<mxPoint as="offset" />
</mxGeometry>
</mxCell>
<mxCell id="dep-e9" edge="1" parent="1" source="opt" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=none;endFill=0;fontSize=11;labelBackgroundColor=#ffffff;" target="det" value="lance le benchmark ;&lt;br&gt;ses agents commitent">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="dep-e10" edge="1" parent="1" source="opt" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=none;endFill=0;fontSize=11;labelBackgroundColor=#ffffff;" target="lab" value="lit auto/ : la vérité">
<mxGeometry relative="1" as="geometry">
<Array as="points" />
</mxGeometry>
</mxCell>
<mxCell id="dep-e11" edge="1" parent="1" source="agents" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=none;endFill=0;fontSize=11;labelBackgroundColor=#ffffff;" target="tools" value="lisent les données par les outils ;&lt;br&gt;le tool-builder y commite">
<mxGeometry relative="1" x="0.088" y="-5" as="geometry">
<mxPoint as="offset" />
<Array as="points">
<mxPoint x="-115" y="420" />
<mxPoint x="-115" y="420" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="dep-e12" edge="1" parent="1" source="agents" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=none;endFill=0;fontSize=11;labelBackgroundColor=#ffffff;" target="lab" value="l&#39;analyste écrit&lt;br&gt;analyses et étiquettes">
<mxGeometry relative="1" x="0.0175" as="geometry">
<Array as="points">
<mxPoint x="360" y="515" />
<mxPoint x="360" y="515" />
</Array>
</mxGeometry>
</mxCell>
</root>
</mxGraphModel>
</diagram>
<diagram name="2. Processus" id="proc">
<mxGraphModel grid="1" page="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" pageScale="1" pageWidth="1720" pageHeight="1110" math="0" shadow="0">
<root>
<mxCell id="0" />
<mxCell id="1" parent="0" />
<mxCell id="titre" parent="1" style="text;html=1;whiteSpace=wrap;align=left;verticalAlign=top;fontSize=14;" value="&lt;b style=&quot;font-size:20px&quot;&gt;Les processus&lt;/b&gt; — chaque case a la couleur du dépôt qui la porte" vertex="1">
<mxGeometry height="30" width="740" x="40" y="16" as="geometry" />
</mxCell>
<mxCell id="leg0" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="Diagnostic-App" vertex="1">
<mxGeometry height="26" width="112" x="790" y="20" as="geometry" />
</mxCell>
<mxCell id="leg1" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="agents" vertex="1">
<mxGeometry height="26" width="112" x="905" y="20" as="geometry" />
</mxCell>
<mxCell id="leg2" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="Optimizer" vertex="1">
<mxGeometry height="26" width="112" x="1020" y="20" as="geometry" />
</mxCell>
<mxCell id="leg3" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="aimsight-data" vertex="1">
<mxGeometry height="26" width="112" x="1135" y="20" as="geometry" />
</mxCell>
<mxCell id="leg4" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="labeling" vertex="1">
<mxGeometry height="26" width="112" x="1250" y="20" as="geometry" />
</mxCell>
<mxCell id="leg5" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="detectors" vertex="1">
<mxGeometry height="26" width="112" x="1365" y="20" as="geometry" />
</mxCell>
<mxCell id="leg6" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="extérieur" vertex="1">
<mxGeometry height="26" width="112" x="1480" y="20" as="geometry" />
</mxCell>
<mxCell id="leg7" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#b0e3e6;strokeColor=#0e8088;fontSize=11;align=center;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="tools" vertex="1">
<mxGeometry height="26" width="112" x="1595" y="20" as="geometry" />
</mxCell>
<mxCell id="l1" parent="1" style="rounded=0;html=1;fillColor=#fafafa;strokeColor=#bbbbbb;" value="" vertex="1">
<mxGeometry height="165" width="1650" x="40" y="70" as="geometry" />
</mxCell>
<mxCell id="l1t" parent="1" style="text;html=1;whiteSpace=wrap;align=left;verticalAlign=top;fontSize=13;" value="&lt;b&gt;1. Pomper&lt;/b&gt;&lt;br&gt;chaque nuit" vertex="1">
<mxGeometry height="149" width="115" x="48" y="78" as="geometry" />
</mxCell>
<mxCell id="s1a" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="Planificateur de Windows, chaque nuit ; ou à la main (tâches VS Code « pomper »)" vertex="1">
<mxGeometry height="60" width="230" x="170" y="85" as="geometry" />
</mxCell>
<mxCell id="s1c" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="Plateforme AIMsight : base et S3" vertex="1">
<mxGeometry height="60" width="230" x="170" y="160" as="geometry" />
</mxCell>
<mxCell id="s1b" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="extraction/pomper.sh → pomper.py, en lecture seule sur la plateforme" vertex="1">
<mxGeometry height="80" width="270" x="480" y="110" as="geometry" />
</mxCell>
<mxCell id="s1d" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="data/&amp;lt;STATION&amp;gt;/ : metrics, displacement, camera, images (hors de git)" vertex="1">
<mxGeometry height="80" width="300" x="840" y="110" as="geometry" />
</mxCell>
<mxCell id="proc-e1" edge="1" parent="1" source="s1a" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.3;entryDx=0;entryDy=0;" target="s1b" value="déclenche">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e2" edge="1" parent="1" source="s1c" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.7;entryDx=0;entryDy=0;" target="s1b" value="lit">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e3" edge="1" parent="1" source="s1b" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s1d" value="écrit">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="l2" parent="1" style="rounded=0;html=1;fillColor=#fafafa;strokeColor=#bbbbbb;" value="" vertex="1">
<mxGeometry height="300" width="1650" x="40" y="255" as="geometry" />
</mxCell>
<mxCell id="l2t" parent="1" style="text;html=1;whiteSpace=wrap;align=left;verticalAlign=top;fontSize=13;" value="&lt;b&gt;2. Analyser une plage&lt;/b&gt;&lt;br&gt;onglet Analysis" vertex="1">
<mxGeometry height="284" width="115" x="48" y="263" as="geometry" />
</mxCell>
<mxCell id="s2a" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="L&#39;expert choisit une plage dans la page Data, avec ses indices : « Analyser la plage »" vertex="1">
<mxGeometry height="90" width="230" x="170" y="320" as="geometry" />
</mxCell>
<mxCell id="s2b" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b&gt;analyste&lt;/b&gt;&lt;br&gt;DETECTEURS = non&lt;br&gt;CONSIGNES = Diagnostic-App/consignes/analyste.md" vertex="1">
<mxGeometry height="110" width="290" x="470" y="310" as="geometry" />
</mxCell>
<mxCell id="s2e" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="auto/analyses/&amp;lt;STATION&amp;gt;_&amp;lt;début&amp;gt;_&amp;lt;fin&amp;gt;/ : rapport, étiquettes, scripts outils/" vertex="1">
<mxGeometry height="90" width="270" x="840" y="320" as="geometry" />
</mxCell>
<mxCell id="s2f" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="étiquettes versées dans auto/&amp;lt;STATION&amp;gt;.jsonl (champ analyse), contrôlées par controle.py" vertex="1">
<mxGeometry height="90" width="250" x="1170" y="320" as="geometry" />
</mxCell>
<mxCell id="s2g" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="rapport affiché ; l&#39;expert répond, l&#39;analyste reprend (--resume)" vertex="1">
<mxGeometry height="90" width="205" x="1470" y="320" as="geometry" />
</mxCell>
<mxCell id="s2c" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#b0e3e6;strokeColor=#0e8088;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="tools : les outils et leur guide (courbes, images, qualité, métriques)" vertex="1">
<mxGeometry height="70" width="200" x="400" y="470" as="geometry" />
</mxCell>
<mxCell id="s2d" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="familles, règles, carte, connaissances ; precedents.py" vertex="1">
<mxGeometry height="70" width="230" x="630" y="470" as="geometry" />
</mxCell>
<mxCell id="proc-e4" edge="1" parent="1" source="s2a" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s2b" value="lance">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e5" edge="1" parent="1" source="s2c" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;" target="s2b" value="lit">
<mxGeometry relative="1" as="geometry">
<Array as="points">
<mxPoint x="500" y="450" />
<mxPoint x="542" y="450" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="proc-e6" edge="1" parent="1" source="s2d" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=1;entryDx=0;entryDy=0;" target="s2b" value="lit">
<mxGeometry relative="1" as="geometry">
<Array as="points">
<mxPoint x="745" y="450" />
<mxPoint x="687" y="450" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="proc-e7" edge="1" parent="1" source="s2b" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s2e" value="écrit">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e8" edge="1" parent="1" source="s2e" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s2f" value="versées&lt;br&gt;par le serveur">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e9" edge="1" parent="1" source="s2f" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s2g" value="">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e10" edge="1" parent="1" source="s2g" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" target="s2b" value="reprend la même session">
<mxGeometry relative="1" as="geometry">
<Array as="points">
<mxPoint x="1572" y="280" />
<mxPoint x="615" y="280" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="l3" parent="1" style="rounded=0;html=1;fillColor=#fafafa;strokeColor=#bbbbbb;" value="" vertex="1">
<mxGeometry height="300" width="1650" x="40" y="575" as="geometry" />
</mxCell>
<mxCell id="l3t" parent="1" style="text;html=1;whiteSpace=wrap;align=left;verticalAlign=top;fontSize=13;" value="&lt;b&gt;3. Optimiser les détecteurs&lt;/b&gt;&lt;br&gt;sur une analyse finie" vertex="1">
<mxGeometry height="284" width="115" x="48" y="583" as="geometry" />
</mxCell>
<mxCell id="s3a" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="« Optimiser les détecteurs » sur une analyse finie ; ou à la main depuis Optimizer" vertex="1">
<mxGeometry height="100" width="200" x="170" y="625" as="geometry" />
</mxCell>
<mxCell id="s3b" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b&gt;improve&lt;/b&gt;, l&#39;orchestrateur : la plage et les étiquettes de l&#39;analyse" vertex="1">
<mxGeometry height="100" width="210" x="400" y="625" as="geometry" />
</mxCell>
<mxCell id="s3c" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="mesures avant : bench/score.py sur la plage, bench/regression.py sur tout labeling/auto" vertex="1">
<mxGeometry height="100" width="230" x="640" y="625" as="geometry" />
</mxCell>
<mxCell id="s3d" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b&gt;upgrader&lt;/b&gt; : corrige les détecteurs, un commit par correction" vertex="1">
<mxGeometry height="100" width="210" x="900" y="625" as="geometry" />
</mxCell>
<mxCell id="s3e" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b&gt;validator&lt;/b&gt; : garde, fait retirer ou annule ; aucune station ne recule" vertex="1">
<mxGeometry height="100" width="230" x="1140" y="625" as="geometry" />
</mxCell>
<mxCell id="s3f" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="seances/&amp;lt;analyse&amp;gt;_&amp;lt;heure&amp;gt;/ : mesures, modification, validation, bilan ; le bilan s&#39;affiche dans l&#39;app" vertex="1">
<mxGeometry height="100" width="275" x="1400" y="625" as="geometry" />
</mxCell>
<mxCell id="s3g" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="auto/ : la vérité, sur la plage et sur toutes les stations" vertex="1">
<mxGeometry height="70" width="250" x="400" y="785" as="geometry" />
</mxCell>
<mxCell id="s3h" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="scripts/, thresholds.md : les détecteurs (commits sur la branche courante, rien n&#39;est poussé)" vertex="1">
<mxGeometry height="70" width="330" x="960" y="785" as="geometry" />
</mxCell>
<mxCell id="proc-e11" edge="1" parent="1" source="s3a" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s3b" value="lance">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e12" edge="1" parent="1" source="s3b" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s3c" value="">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e13" edge="1" parent="1" source="s3c" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s3d" value="">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e14" edge="1" parent="1" source="s3d" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s3e" value="">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e15" edge="1" parent="1" source="s3e" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s3f" value="">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e16" edge="1" parent="1" source="s3g" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.3;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;" target="s3b" value="lit">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e17" edge="1" parent="1" source="s3g" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.8;exitY=0;exitDx=0;exitDy=0;entryX=0.3;entryY=1;entryDx=0;entryDy=0;" target="s3c" value="lit">
<mxGeometry relative="1" as="geometry">
<Array as="points">
<mxPoint x="600" y="755" />
<mxPoint x="709" y="755" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="proc-e18" edge="1" parent="1" source="s3d" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.2;entryY=0;entryDx=0;entryDy=0;" target="s3h" value="commite">
<mxGeometry relative="1" as="geometry">
<Array as="points">
<mxPoint x="1005" y="755" />
<mxPoint x="1026" y="755" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="proc-e19" edge="1" parent="1" source="s3e" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.8;entryY=0;entryDx=0;entryDy=0;" target="s3h" value="retire ou annule">
<mxGeometry relative="1" as="geometry">
<Array as="points">
<mxPoint x="1255" y="755" />
<mxPoint x="1224" y="755" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="l4" parent="1" style="rounded=0;html=1;fillColor=#fafafa;strokeColor=#bbbbbb;" value="" vertex="1">
<mxGeometry height="190" width="1650" x="40" y="895" as="geometry" />
</mxCell>
<mxCell id="l4t" parent="1" style="text;html=1;whiteSpace=wrap;align=left;verticalAlign=top;fontSize=13;" value="&lt;b&gt;4. Améliorer les outils&lt;/b&gt;&lt;br&gt;après l&#39;optimisation" vertex="1">
<mxGeometry height="174" width="115" x="48" y="903" as="geometry" />
</mxCell>
<mxCell id="s4a" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="à la fin de l&#39;optimisation (même bouton)" vertex="1">
<mxGeometry height="60" width="230" x="170" y="910" as="geometry" />
</mxCell>
<mxCell id="s4c" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="auto/analyses/&amp;lt;a&amp;gt;/ : rapport, analyse, scripts outils/ de l&#39;analyste" vertex="1">
<mxGeometry height="80" width="230" x="170" y="990" as="geometry" />
</mxCell>
<mxCell id="s4b" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="&lt;b&gt;tool-builder&lt;/b&gt;&lt;br&gt;la requête de l&#39;app : l&#39;analyse et ses scripts" vertex="1">
<mxGeometry height="90" width="270" x="480" y="940" as="geometry" />
</mxCell>
<mxCell id="s4d" parent="1" style="rounded=1;arcSize=4;whiteSpace=wrap;html=1;fillColor=#b0e3e6;strokeColor=#0e8088;fontSize=12;align=left;verticalAlign=top;spacingLeft=8;spacingRight=8;spacingTop=4;" value="tools : les outils et leur guide ; optimise ou ajoute, ne retire rien ; commite" vertex="1">
<mxGeometry height="90" width="330" x="840" y="940" as="geometry" />
</mxCell>
<mxCell id="proc-e20" edge="1" parent="1" source="s4a" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.3;entryDx=0;entryDy=0;" target="s4b" value="lance">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e21" edge="1" parent="1" source="s4c" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.75;entryDx=0;entryDy=0;" target="s4b" value="lit">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="proc-e22" edge="1" parent="1" source="s4b" style="edgeStyle=orthogonalEdgeStyle;rounded=1;html=1;endArrow=block;endFill=1;fontSize=11;labelBackgroundColor=#ffffff;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="s4d" value="commite">
<mxGeometry relative="1" as="geometry" />
</mxCell>
</root>
</mxGraphModel>
</diagram>
</mxfile>
@@ -0,0 +1,142 @@
# English translation and renames: the shared names
2026-11-16. Decided by the user: everything in the seven repositories of the architecture (`docs/architecture.drawio`) goes to English, the labels of `labeling/auto` included, and French file names and identifiers are renamed. This table fixes every name that crosses a file or a repository boundary; inside a file, translate freely but consistently. Conversations with the user stay in French; the repositories are in English.
## Rules for every translator
- Text (docs, prompts, comments, docstrings, program output, UI, label descriptions): English, same meaning, same structure, nothing added or dropped. Keep proper nouns, sensor names (PR04, CTR03), station names, label ids (NORDEND-243), family keys, numbers, units, dates and date formats exactly as they are.
- The evidence vocabulary stays as it is: `confirmed`, `strongly supported`, `consistent with`, `possible`, `insufficient evidence`, `not observed`.
- History references (D-119, E-004, "wf-improve session X, mod. 1, S2", commit hashes) stay as they are.
- Frozen, not translated (a README in each may be translated): `Optimizer/archive/**`, `labeling/docs/archive/**`, `Diagnostic-App/docs/superpowers/**` (plans and specs are history), `labeling/manual/*.jsonl` descriptions (the user's own; only their keys are migrated).
- Never touch `.env`; never copy metric identifiers (`SIM_CCID`, `ip*`).
- Do not commit: the orchestrator commits each repository after the integration checks.
## 1. Label files (`labeling/auto/*.jsonl`, `labeling/manual/*.jsonl`, an analysis' `labels.jsonl`)
| French key | English key |
|---|---|
| `id` | `id` |
| `debut` | `start` |
| `fin` | `end` |
| `categorie` | `family` |
| `description` | `description` |
| `revue` | `review` |
| `analyse` | `analysis` |
Family values do not change (`Visibility`, `Obstruction`, `Target issue`, `Thermal displacement`, `No data`, `Displacement`). New labels are written in English.
## 2. labeling
| Before | After |
|---|---|
| `familles.md` | `families.md` (its table column « Pour le client » → "For the client") |
| `regles-d-etiquetage.md` | `labeling-rules.md` |
| `carte-des-etiquettes.md` | `label-map.md` |
| `connaissances/` | `knowledge/` |
| `connaissances/cas-annotes-par-l-expert.md` | `knowledge/expert-annotated-cases.md` |
| `connaissances/chaine-de-mesure.md` | `knowledge/measurement-chain.md` |
| `connaissances/colonnes-des-deplacements.md` | `knowledge/displacement-columns.md` |
| `connaissances/cycle-thermique.md` | `knowledge/thermal-cycle.md` |
| `connaissances/images-de-la-camera.md` | `knowledge/camera-images.md` |
| `connaissances/incident-de-barcelone.md` | `knowledge/barcelona-incident.md` |
| `connaissances/les-trous.md` | `knowledge/gaps.md` |
| `connaissances/metriques-de-qualite.md` | `knowledge/quality-metrics.md` |
| `controle.py` | `validate.py` |
| `ids.py`, `precedents.py` | unchanged names |
| `precedents.py --exclure`, `--famille` | `--exclude`, `--family` (`--k`, `--index`, `--check` unchanged) |
Provenance strings of `precedents.py`: `auto, reviewed on <date>`, `auto, not reviewed (analysis <name>)`.
## 3. An analysis folder (`labeling/auto/analyses/<STATION>_<start>_<end>/`)
| Before | After |
|---|---|
| `demande.json` (keys `station`, `debut`, `fin`, `indices`) | `request.json` (keys `station`, `start`, `end`, `hints`) |
| `etiquettes.jsonl` | `labels.jsonl` |
| `analyse.md` | `analysis.md` |
| `rapport.md` | `report.md` |
| `outils/` (the analyst's scripts) | `scripts/` |
| `outils.md` (the tool-builder's report) | `tools.md` |
| `travail/` | `work/` |
| `travail/journal.jsonl` | `work/log.jsonl` |
| `travail/session` | `work/session` |
| `travail/versees.jsonl` | `work/submitted.jsonl` |
| `travail/optimisation.jsonl` | `work/optimization.jsonl` |
Figures keep their file names unless the report translator renames them and fixes every link to them.
## 4. tools (`~/tools`)
Files (`scripts/`): `donnees.py` → `data.py`, `inventaire.py` → `inventory.py`, `resume.py` → `summary.py`, `plages.py` → `ranges.py`, `jours.py` → `days.py`, `ensemble.py` → `overview.py`, `metriques.py` → `metrics.py`, `qualite.py` → `quality.py`, `stations.py` → `stations.py`, `graphique.py` → `plot.py`, `vignettes.py` → `thumbnails.py`, `gif.py` → `gif.py`. `GUIDE.md` keeps its name.
Names imported from another file (exactly these):
| Module | Before → after |
|---|---|
| `data` (ex `donnees`) | `charger` → `load`, `charger_camera` → `load_camera`, `charger_temperature` → `load_temperature`, `charger_metriques` → `load_metrics`, `est_reference` → `is_reference`, `rejetee` → `rejected`, `filtrer` → `filter_window`, `instant` → `parse_time`, `iso` → `iso`, `heure_image` → `image_time`, `trouver` → `find_files`, `POSE` → `POSE` |
| `plot` (ex `graphique`) | `borne` → `bound`, `COLONNES` → `COLUMNS` |
| `summary` (ex `resume`) | `QUALITE` → `QUALITY`, `ARRONDI` → `ROUNDING`, `bruit_propre` → `own_noise`, `duree` → `duration`, `STATS` → `STATS`, `COLONNES` → `COLUMNS` |
| `inventory` (ex `inventaire`) | `METRIQUE_RE` → `METRIC_RE` |
| `metrics` (ex `metriques`) | `cibles` → `targets`, `coupe` → `cut`, `suites` → `runs` |
The app (`Diagnostic-App/app/server/station.py`) imports `data` and uses `load`, `load_camera`, `image_time`, `parse_time`, `iso`.
Command-line options:
| Before | After | Before | After |
|---|---|---|---|
| `--autres` | `--others` | `--marge` | `--margin` |
| `--bords` | `--edges` | `--marque` | `--mark` |
| `--bornes` | `--bounds` | `--metriques` | `--metrics` |
| `--calme` | `--calm` | `--metriques-seules` | `--metrics-only` |
| `--capteurs` | `--sensors` | `--min-mesures` | `--min-measurements` |
| `--colonne` | `--column` | `--niveau periode\|fenetre` | `--level period\|window` |
| `--colonnes` | `--columns` | `--noms` | `--names` |
| `--commun` | `--common` | `--nuit` | `--night` |
| `--contraste` | `--contrast` | `--numeros` | `--numbers` |
| `--contre` | `--against` | `--pas` | `--step` |
| `--debut` | `--start` | `--rayon` | `--radius` |
| `--duree` | `--duration` | `--residus …\|non` | `--residuals …\|no` |
| `--etiquettes` | `--labels` | `--rigide` | `--rigid` |
| `--fichiers` | `--files` | `--sans` | `--without` |
| `--fin` | `--end` | `--sauf` | `--except` |
| `--fixe` | `--fixed` | `--seuil` | `--threshold` |
| `--fusion` | `--merge` | `--sortie` | `--out` |
| `--glissant` | `--rolling` | `--suivre` | `--follow` |
| `--heures` | `--times` | `--table T1/T2\|non` | `--table T1/T2\|no` |
| `--hors` | `--outside` | `--essai` | `--self-test` |
| `--jours` | `--days` | `--lissage` | `--smoothing` |
| `--largeur` | `--width` | | |
Unchanged: `--figure`, `--fraction`, `--instants`, `--k`, `--max`, `--min`, `--stat median|min|max`, `--zone`. Default output folder: `out/diagnostic` (unchanged). Output: English text, every number, date format and column order identical.
## 5. agents (`~/agents`)
- `agents/analyste.md` → `agents/analyst.md`, agent `agents:analyst`. Its request: `Station: data/<STATION>/. Range: <start> → <end> (UTC). Hints: <…> | none. Output folder: <folder>/. DETECTORS: yes | no. Events: <command> (only with DETECTORS: yes). INSTRUCTIONS: <file>.`
- `agents/tool-builder.md`, agent `agents:tool-builder`. Its request: `Analysis: <analysis folder>/. Tools: <tools repository>/. Write <report>.`
- `upgrader`, `validator`: already English.
## 6. Diagnostic-App
- `consignes/analyste.md` → `instructions/analyst.md`.
- `app/serveur/` → `app/server/`: `serveur.py` → `server.py`, `station.py`, `analyse.py` → `analysis.py`, `check.py`.
- `app/web/src/commun.jsx` → `app/web/src/common.jsx`; `App.jsx`, `main.jsx`, `pages/Data.jsx`, `pages/Images.jsx` keep their names.
- API: `/api/courbes` → `/api/curves`, `/api/detecteurs` → `/api/detectors`, `/api/etiquettes` → `/api/labels`, `/api/analyses/{name}/rapport.html` → `report.html`, `/optimiser` → `/optimize`, `/bilan.html` → `/summary.html`; the others unchanged. JSON fields between server and page: English, chosen by the Diagnostic-App translator, the same on both sides.
- Environment variables `AIMSIGHT_DATA`, `AIMSIGHT_LABELS`, `AIMSIGHT_PORT`, the VS Code task "Run app" and the six links (`data`, `labeling`, `detectors`, `tools`, `agents`, `optimizer`) keep their names.
## 7. Optimizer
- `seances/` → `sessions/` (the default `OUT` of `improve`: `sessions/<analysis>_<YYYYMMDDTHHMMZ>/`).
## 8. detectors
- Already English. `bench/score.py` and `bench/regression.py` read the label keys of section 1 (`start`, `end`, `family`, `description`); `CLAUDE.md` and `README.md` say so (the "French keys" line goes).
## 9. aimsight-data
- `extraction/pomper.py` → `extraction/pump.py`, `extraction/pomper.sh` → `extraction/pump.sh`, `extraction/lenzspitze_absolu.py` → `extraction/lenzspitze_absolute.py`; `stations.txt` unchanged.
- Options: `--du` → `--from`, `--au` → `--to`, `--delai` → `--delay`; `--diff`, `--every`, `--images`, `--out` unchanged.
- `out/pompage.log` → `out/pump.log`, `out/pompage.lock` → `out/pump.lock`.
- VS Code tasks: « pomper » → "pump", « pomper une plage » → "pump a range".
- The Windows Task Scheduler task « AIMsight pompage » keeps its name; its action points to `extraction/pump.sh` (updated by the orchestrator with `schtasks.exe`).
- `.env` variable names do not change.
@@ -0,0 +1,164 @@
# Refonte des dépôts : plan de mise en œuvre
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal :** aligner les dépôts sur l'architecture validée le 2026-11-16 : une responsabilité par dépôt, deux dépôts nouveaux (`tools`, `agents`), l'auto-étiquetage d'Optimizer archivé.
**Architecture :** `tools` (le harnais de lecture) et `agents` (les agents génériques, en plugin Claude Code) naissent des morceaux de Diagnostic-App et de detectors. detectors n'est plus qu'eux et leur benchmark. Optimizer reçoit l'orchestrateur de l'optimisation. Diagnostic-App ne garde que l'app, qui lance des processus dont le code vit ailleurs. Chaque dépôt atteint les autres par des liens ignorés par git, comme aujourd'hui `data`, `labeling` et `detectors`.
**Tech Stack :** Python 3 (bibliothèque standard ; matplotlib par `.venv/bin/python` pour les figures), FastAPI et React (l'app), Claude Code (`claude -p`, `--plugin-dir`, `--agent`).
**Spec :** `~/Diagnostic-App/docs/architecture.drawio` (2 pages : Dépôts, Processus), validé par l'utilisateur, et cette conversation pour ce qui suit.
## Décisions de la conversation
- Les détecteurs s'entraînent sur `labeling/auto` (toutes ses étiquettes).
- `tools` ne contient que le harnais de lecture : les 12 outils de `agent-tools/`, leur guide, `donnees.py`. Le benchmark reste dans detectors (`bench/`), `controle.py`, `ids.py` et `precedents.py` dans labeling.
- Un agent du plugin se lance par `claude -p "<requête>" --plugin-dir <agents> --agent agents:<nom>` (essayé le 2026-11-16) ; dans un workflow, par l'outil Agent, `subagent_type: agents:<nom>`. Claude refuse d'écrire dans un plugin chargé : `tools` et detectors ne sont pas des plugins, et le tool-builder ne charge que `agents`.
- L'analyste a deux paramètres dans sa requête : `DETECTEURS : oui | non`, et `CONSIGNES : <fichier>`, les consignes de l'appelant.
- Les séances d'optimisation vont dans `Optimizer/seances/<analyse>_<AAAAMMJJTHHMMZ>/`, non commitées par la séance (comme aujourd'hui). Le rendu du tool-builder reste `<analyse>/outils.md`.
- Hors de la refonte : aimsight-data, Support-LibreDesk, Support-Agent et Support-AI (dépôts d'essai), monitoring-dashboard.
## Global Constraints
- Toute heure est en UTC.
- Bibliothèque standard pour les détecteurs et les outils ; matplotlib par `.venv/bin/python`, pour les figures seulement.
- Pas de règle propre à une station, une cible ou une date.
- Lecture seule sur `data/` ; ne jamais recopier les identifiants des métriques (`SIM_CCID`, `ip*`) ; ne jamais lire `.env`.
- Commits par chemin, jamais `git add -A` ; chaque message finit par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`. Rien n'est poussé sans l'accord de l'utilisateur.
- Langue : français ; detectors, `upgrader`, `validator` et le skill `improve` restent en anglais.
- Les agents tournent sur l'abonnement Claude, jamais sur une clé d'API.
- Un déplacement de code laisse chaque chiffre du benchmark inchangé.
- Entre la tâche 3 et la fin de la tâche 5, le bouton « Optimiser » de l'app ne marche pas : enchaîner ces tâches.
## Review Focus
- Une nouvelle analyse de la même plage s'appelle `<nom>_<HHMMSS>` : le bilan de `<nom>` ne doit jamais être celui d'une séance de `<nom>_<HHMMSS>` (tâche 5, `check_optimisation`).
- Un outil lancé par le lien `tools/` sans `--sortie` écrit dans `out/diagnostic/` du dépôt d'où on le lance, pas dans `~/out` (tâche 1, étape 4).
- Un message à l'analyste (`--resume`) relance le même agent du plugin : `--plugin-dir` et `--agent agents:analyste` sont dans la commande de reprise (tâche 5, `check_analyse`).
- Un lien `optimizer/` ou `agents/` manquant donne un refus clair au clic sur « Optimiser », pas une trace d'erreur (tâche 5, `check_optimisation`).
- Le benchmark donne les mêmes chiffres depuis `bench/` que depuis l'ancien chemin (tâche 3, étape 5).
---
### Task 1 : le dépôt tools, le harnais de lecture
**Files :**
- Create : `~/tools/` (dépôt git, branche `main`) : les 12 scripts de `~/Diagnostic-App/agent-tools/*.py`, copiés tels quels ; `GUIDE.md` (copie de `~/Diagnostic-App/.claude/skills/lire-les-donnees/SKILL.md`) ; `README.md` ; `CLAUDE.md` ; `.gitignore` (`__pycache__/`, `out/`)
- Modify (dans `~/tools`) : `graphique.py:23`, `gif.py:19`, `vignettes.py:45`, `qualite.py:52` et les `--sortie` par défaut de `graphique`, `gif`, `vignettes`, `metriques`, `jours`, `stations`, `ensemble` ; les imports `from graphique import … RACINE …` de `ensemble.py:66`, `metriques.py:38`, `stations.py:37`, `jours.py:59` ; les lignes `Usage :` de chaque script
- Modify : `~/labeling/regles-d-etiquetage.md:94`, `~/labeling/connaissances/images-de-la-camera.md:18`
**Interfaces :**
- Produces : `~/tools/<outil>.py` (mêmes options, mêmes sorties qu'avant), `~/tools/GUIDE.md`, `~/tools/donnees.py` (même API : `charger`, `charger_temperature`, `charger_camera`, `charger_metriques`, …). Les appelants l'atteignent par un lien `tools -> ~/tools` et lancent `python3 tools/<outil>.py data/<STATION> …` depuis leur racine.
- [ ] **Étape 1 : créer le dépôt et copier.** `git init -b main ~/tools`, puis copier les 12 scripts et le guide. Noter le commit de Diagnostic-App copié (`git -C ~/Diagnostic-App rev-parse --short HEAD`) pour le README.
- [ ] **Étape 2 : les sorties par défaut relatives au dossier courant.** Remplacer `os.path.join(RACINE, "out", "diagnostic")` par `os.path.join("out", "diagnostic")` partout ; retirer `RACINE`, qui ne sert qu'à cela (le vérifier par `grep -n RACINE *.py`, qui doit ne plus rien rendre). Dans les `Usage :`, `agent-tools/` devient `tools/`.
- [ ] **Étape 3 : le guide.** Dans `GUIDE.md` : retirer l'en-tête YAML ; `agent-tools/` devient `tools/` (11 fois) ; « Lance-les depuis la racine du dépôt » devient « Lance-les depuis la racine du dépôt appelant, où `tools/`, `data/` et `labeling/` sont des liens » ; la ligne de description dit : suivi par l'analyste, amélioré par le tool-builder.
- [ ] **Étape 4 : vérifier, ancien face à nouveau.** Depuis `~/Diagnostic-App`, après `ln -s ~/tools tools` : pour chacun des 12 outils, la première commande d'exemple du guide sur `data/NORDEND --debut 2026-11-05T00:00Z --fin 2026-11-06T00:00Z`, une fois par `agent-tools/`, une fois par `tools/`, avec le même `--sortie` dans le scratchpad pour les outils à figures (le chemin du PNG s'imprime : il doit être le même).
Attendu : sortie texte identique (`diff` vide), code de sortie 0, les mêmes noms de PNG. Puis `.venv/bin/python tools/graphique.py data/NORDEND --debut 2026-11-05T00:00Z --fin 2026-11-06T00:00Z` sans `--sortie` : le PNG est dans `~/Diagnostic-App/out/diagnostic/`, rien dans `~/out/`.
- [ ] **Étape 5 : README et CLAUDE.md.** README : la responsabilité (« le harnais de lecture : les méthodes données à l'agent pour appréhender les données »), la liste des outils (renvoi au guide), comment l'appeler (le lien `tools`), « seul le tool-builder y écrit : il optimise ou ajoute, ne retire rien », l'origine (copié de Diagnostic-App `<commit>`), l'architecture (`~/Diagnostic-App/docs/architecture.drawio`). CLAUDE.md : les interdits du tool-builder repris de `~/Diagnostic-App/.claude/agents/tool-builder.md:31-38` (aucun jugement dans une sortie, rien de propre à une station, aucun import des détecteurs, bibliothèque standard, jamais d'identifiant de `metrics/`, ne rien casser, `donnees.py` seulement pour une erreur de lecture), plus les règles globales.
- [ ] **Étape 6 : labeling.** `agent-tools/qualite.py` devient `tools/qualite.py` ; « `agent-tools/donnees.py` de Diagnostic-App » devient « `tools/donnees.py` (dépôt tools) ».
- [ ] **Étape 7 : commiter.** Dans `~/tools` : `git add -- *.py GUIDE.md README.md CLAUDE.md .gitignore && git commit -m "tools : le harnais de lecture, copié de Diagnostic-App (<commit>)"`. Dans `~/labeling` : commit par chemin des deux notes, « Notes : les outils de lecture sont dans le dépôt tools ».
### Task 2 : le dépôt agents, les agents génériques
**Files :**
- Create : `~/agents/` (dépôt git, `main`) : `.claude-plugin/plugin.json`, `agents/analyste.md`, `agents/tool-builder.md`, `agents/upgrader.md`, `agents/validator.md`, `README.md`, `CLAUDE.md`, `.gitignore` (`__pycache__/`)
**Interfaces :**
- Consumes : `tools/GUIDE.md`, `tools/*.py` (tâche 1) ; `<DETECTORS>/bench/{score,regression,sensors}.py` (tâche 3).
- Produces : les agents `agents:analyste`, `agents:tool-builder`, `agents:upgrader`, `agents:validator`, et leurs requêtes :
- analyste : `Station : data/<STATION>/. Plage : <début> → <fin> (UTC). Indices de l'utilisateur : <…>. Dossier de sortie : <dossier>/. DETECTEURS : oui|non. CONSIGNES : <fichier>.`
- tool-builder : `Analyse : <dossier de l'analyse>/. Outils : <dépôt tools>/. Écris <rendu>.`
- upgrader, validator : les requêtes de l'étape 2 et de l'étape 4 du skill `improve` (tâche 4), inchangées sauf les chemins.
- [ ] **Étape 1 : le plugin.** `plugin.json` : `{"name": "agents", "description": "Les agents génériques AIMsight : analyste, tool-builder, upgrader, validator ; l'appelant donne ses paramètres et ses consignes dans la requête."}`.
- [ ] **Étape 2 : l'analyste générique**, depuis `~/Diagnostic-App/.claude/agents/analyste.md`. Il garde la méthode (l. 9-11 sans la phrase sur la page Data), les sources (l. 20-31, le guide devient `tools/GUIDE.md`), les outils (l. 33-35, `tools/qualite.py`), le déroulé (l. 37-41), les étiquettes (l. 43-55) et le plan de `analyse.md` (l. 57-83). Il ajoute une section « Ta requête » : les champs ci-dessus ; `CONSIGNES` se lit en entier avant tout et prime sur ce fichier, sauf pour les règles d'une étiquette et pour `DETECTEURS`. `DETECTEURS : non` : ni le code ni la sortie des détecteurs, puisque les étiquettes serviront à les améliorer. `DETECTEURS : oui` : la commande des événements que donne la requête est un indice à vérifier sur les données, jamais une étiquette à recopier ; l'analyse dit ce qu'il en a tiré. Le rapport, le dialogue et le versement passent dans les consignes de l'appelant (tâche 5). En-tête : `name: analyste`, une description générique, `tools: Read, Bash, Write`, `model: inherit`, `omitClaudeMd: true`.
- [ ] **Étape 3 : le tool-builder générique**, depuis `~/Diagnostic-App/.claude/agents/tool-builder.md`. Mêmes décisions et mêmes interdits ; il ne touche que `<Outils>/*.py` et `<Outils>/GUIDE.md` ; il commite dans le dépôt tools (`git -C <Outils> commit -m "Outils : <analyse>" -- <ses fichiers>`) sur sa branche courante, et ne commite pas son rendu. Les mentions de la page Data et d'`agent-tools/` disparaissent.
- [ ] **Étape 4 : upgrader et validator**, copiés de `~/detectors/agents/`. `<DETECTORS>/skills/wf-improve/scripts/` devient `<DETECTORS>/bench/` ; « wf-improve workflow » devient « improve workflow (Optimizer) » ; `upgrader.md:34`, « never `skills/`, `agents/` », devient « never `bench/` ».
- [ ] **Étape 5 : README et CLAUDE.md.** README : la responsabilité (« les agents génériques, un seul exemplaire de chacun »), la table agent → paramètres → qui l'appelle (analyste : Diagnostic-App ; tool-builder : Diagnostic-App ; upgrader, validator : Optimizer), comment les lancer (les deux formes des décisions), le contrat de l'appelant (sa racine porte les liens `data/`, `labeling/`, `tools/`, et `detectors/` si besoin), l'architecture. CLAUDE.md : rien de propre à un appelant ici (chemins de sortie, format de rapport, règles git de l'appelant : tout passe par la requête ou le fichier de consignes) ; un agent ne sert ici que s'il est générique.
- [ ] **Étape 6 : vérifier que l'agent se charge.** Depuis `~/Diagnostic-App` : `env -u ANTHROPIC_API_KEY claude -p "Sans rien lire ni lancer, cite les champs de ta requête et ce que change DETECTEURS." --plugin-dir ~/agents --agent agents:analyste --model haiku --setting-sources project,local --strict-mcp-config`.
Attendu : la réponse nomme `DETECTEURS` et `CONSIGNES`. Même essai pour `agents:tool-builder` (attendu : `Analyse`, `Outils`).
- [ ] **Étape 7 : commiter.** `git add -- .claude-plugin agents README.md CLAUDE.md .gitignore && git commit -m "agents : les agents génériques (analyste, tool-builder de Diagnostic-App ; upgrader, validator de detectors)"`.
### Task 3 : detectors, les détecteurs et leur benchmark
**Files :**
- Move : `~/detectors/skills/wf-improve/scripts/{score,regression,sensors}.py` → `~/detectors/bench/`
- Modify : `bench/score.py:20`, `bench/sensors.py:12` (`parents[3]` → `parents[1]`) ; `README.md` ; `CLAUDE.md:7-23`
- Delete : `~/detectors/.claude-plugin/`, `~/detectors/skills/`, `~/detectors/agents/` (copiés à la tâche 2)
**Interfaces :**
- Produces : `python3 <DETECTORS>/bench/score.py <station> --labels <f> --from <j> --to <j>`, `python3 <DETECTORS>/bench/regression.py --labels <dossier> --data <dossier> [--stations A,B --from --to]`, `python3 <DETECTORS>/bench/sensors.py <station> --from --to` : mêmes options et sorties qu'avant. `scripts/` et `categories.events` restent inchangés.
- [ ] **Étape 1 : le benchmark avant.** Depuis `~/detectors` : `python3 skills/wf-improve/scripts/regression.py --labels ~/labeling/auto --data ~/aimsight-data/data > <scratchpad>/bench-avant.txt` (~3 min).
- [ ] **Étape 2 : déplacer.** `git mv skills/wf-improve/scripts bench`, puis `parents[3]` → `parents[1]` aux deux lignes.
- [ ] **Étape 3 : retirer le plugin.** `git rm -r .claude-plugin skills agents`.
- [ ] **Étape 4 : README et CLAUDE.md.** README : « Improving them » devient « Measuring them: `bench/` » (les trois commandes) ; « The detectors are improved by Optimizer (`improve` skill) with the upgrader and validator of the agents repository » ; plus de plugin ; l'architecture. CLAUDE.md : les outils vont dans `bench/` (l. 7) ; les consommateurs (l. 9-13) : Diagnostic-app (`categories.events`, `categories.CATEGORIES`, les CLI `--from/--to`), Optimizer (`bench/`, `categories.events`, `scripts/` et `thresholds.md` modifiés par l'upgrader) ; la section « The workflow stays generic » part (elle vit dans Optimizer) ; la commande du benchmark devient `python3 bench/regression.py …`. Les références d'historique (« wf-improve session X, mod. 1, S2 ») restent telles quelles dans `scripts/` et `thresholds.md`.
- [ ] **Étape 5 : le benchmark après.** `python3 bench/regression.py --labels ~/labeling/auto --data ~/aimsight-data/data > <scratchpad>/bench-apres.txt`, puis `diff <scratchpad>/bench-avant.txt <scratchpad>/bench-apres.txt`.
Attendu : `diff` vide.
- [ ] **Étape 6 : commiter.** `git commit -m "Le benchmark dans bench/ ; plus de plugin : l'amélioration vit dans Optimizer, ses agents dans le dépôt agents" -- bench skills agents .claude-plugin README.md CLAUDE.md`.
### Task 4 : Optimizer, l'optimisation des détecteurs
**Files :**
- Move (dans `~/Optimizer`) : `batch.py`, `.claude/agents/scanner.md`, `batches/`, `outils/`, `docs/` → `archive/` (`archive/scanner.md`, `archive/batches/`, `archive/outils/`, `archive/docs/`)
- Create : `archive/README.md` ; `.claude/skills/improve/SKILL.md` ; le lien `agents -> ~/agents`
- Modify : `.gitignore` (les motifs `batches/…` deviennent `archive/batches/…` ; ajouter `agents`), `README.md`, `CLAUDE.md`
**Interfaces :**
- Consumes : `agents:upgrader`, `agents:validator` (tâche 2) ; `<DETECTORS>/bench/` (tâche 3).
- Produces : le skill `/improve`, lancé depuis la racine d'Optimizer : `claude -p "/improve DETECTORS: detectors/. STATION: data/<S>. FROM: <j>. TO: <j>. LABELS: labeling/auto/<S>.jsonl. REFERENCE: --labels labeling/auto --data data. FAMILIES: labeling/familles.md. CONTEXT: labeling/auto/analyses/<a>/rapport.md. OUT: seances/<a>_<AAAAMMJJTHHMMZ>/. <contexte de l'appelant>" --plugin-dir <agents> --add-dir <cibles réelles de detectors, data, labeling> --allowedTools Read,Write,Edit,Bash,Agent --permission-mode acceptEdits`. Le bilan : `<OUT>/summary.md`.
- [ ] **Étape 1 : archiver.** `mkdir archive`, puis `git mv` des cinq chemins ; les fichiers ignorés de `batches/` suivent le dossier. `archive/README.md`, en cinq lignes : ce que c'était (un batch par jour ; les détecteurs étiquettent, le scanner corrige de loin, wf-improve apprend de ces corrections) ; arrêté le 2026-11-16 par l'utilisateur, beaucoup de quantité sans la qualité, et un effet circulaire (les détecteurs appris sur leurs propres étiquettes corrigées) ; gardé pour trace, non maintenu.
- [ ] **Étape 2 : le skill `improve`**, depuis `~/detectors/skills/wf-improve/SKILL.md` (lu avant sa suppression à la tâche 3, ou dans l'historique : `git -C ~/detectors show HEAD~1:skills/wf-improve/SKILL.md`). `name: improve` ; les commandes passent par `<DETECTORS>/bench/` ; les agents sont `agents:upgrader` et `agents:validator`, chargés par `--plugin-dir` (absents : le dire et s'arrêter sans rien toucher) ; `OUT` vaut `seances/<nom>_<AAAAMMJJTHHMMZ>/` par défaut ; les commits portent `improve: S<n>`, `improve: S<n> removed`, `improve: modification cancelled` (la recherche `': S[0-9]*$'` reste juste) ; le titre du bilan devient `# improve: …`. Le reste (entrées, git, étapes, bilan, réponse) reste tel quel.
- [ ] **Étape 3 : README et CLAUDE.md.** La responsabilité (« l'optimisation des détecteurs, sur les étiquettes de `labeling/auto` ») ; les liens (`data`, `labeling`, `detectors`, `agents`) ; la commande ci-dessus, à la main ou par le bouton de l'app ; les séances dans `seances/`, non commitées par la séance ; `archive/` ; les règles (abonnement et non clé d'API, lecture seule sur `data/` et `labeling/`, rien de propre à une station) ; l'architecture. Plus de `.venv` ni de matplotlib.
- [ ] **Étape 4 : vérifier que le skill se charge.** `ln -s ~/agents agents`, puis depuis `~/Optimizer` : `env -u ANTHROPIC_API_KEY claude -p "/improve" --plugin-dir agents --model haiku --setting-sources project,local --strict-mcp-config`.
Attendu : il dit qu'il manque les entrées obligatoires et s'arrête ; `git -C ~/detectors status --porcelain` reste vide.
- [ ] **Étape 5 : commiter.** `git commit -m "Optimizer : l'optimisation des détecteurs depuis une analyse (skill improve, ex wf-improve) ; le batch et le scanner archivés" -- archive batch.py batches outils docs .claude .gitignore README.md CLAUDE.md`.
### Task 5 : Diagnostic-App, le poste de pilotage
**Files :**
- Create : `consignes/analyste.md` ; les liens `tools -> ~/tools`, `agents -> ~/agents`, `optimizer -> ~/Optimizer`
- Modify : `.gitignore` (+ `tools`, `agents`, `optimizer`) ; `app/serveur/station.py:1-30` ; `app/serveur/analyse.py` ; `app/serveur/check.py:100-177` ; `app/web/src/pages/Data.jsx:490-491, 527, 555` ; `README.md`, `CLAUDE.md`, `app/README.md`
- Delete : `agent-tools/`, `.claude/agents/`, `.claude/skills/` (garder `.claude/settings.json`)
**Interfaces :**
- Consumes : `tools/donnees.py` (tâche 1) ; `agents:analyste`, `agents:tool-builder` et leurs requêtes (tâche 2) ; `/improve` et `seances/` (tâche 4) ; `detectors/bench/score.py` (tâche 3).
- Produces : `station.TOOLS = RACINE / "tools"` ; `station.liens()` → `--add-dir` des cibles réelles de `data/`, `labeling/`, `tools/` ; `analyse.AGENTS = station.RACINE / "agents"`, `analyse.OPTIMIZER = station.RACINE / "optimizer"`, `analyse.SEANCES = OPTIMIZER / "seances"`.
- [ ] **Étape 1 : les tests d'abord**, dans `check.py`.
- `check_optimisation` : `analyse.OPTIMIZER`, `analyse.SEANCES` et `analyse.AGENTS` pointent vers un dossier temporaire. Sans `.claude/skills/improve/SKILL.md` ou sans `.claude-plugin/plugin.json`, `leve(analyse.optimiser, "NORDEND_a")` ; puis on les crée. `FauxProcessus` garde `(args, kwargs)`. Premier lancement : `args[2].startswith("/improve ")`, `"STATION: data/NORDEND. FROM: 2026-11-04. TO: 2026-11-08." in args[2]`, `"OUT: seances/NORDEND_a_" in args[2]`, `kwargs["cwd"] == analyse.OPTIMIZER.resolve()`, `"--plugin-dir" in args`. Second lancement : `"agents:tool-builder" in args` et `"Outils : tools/" in args[2]`. Le bilan se lit dans `SEANCES/"NORDEND_a_20261113T1000Z"/summary.md` (avec `<analyse>/outils.md`, comme aujourd'hui). Une séance `SEANCES/"NORDEND_a_143000_20261113T1100Z"/summary.md` laisse `analyse._bilan("NORDEND_a")` sur la séance de `NORDEND_a`.
- `check_analyse`, nouveau, ajouté à `CHECKS` : `analyse.DOSSIER` temporaire, `Popen` remplacé, `analyse.verser` remplacé par `lambda *a: 0` (sinon le test réécrit le vrai `labeling/auto/NORDEND.jsonl`) ; `analyse.lancer({"station": "NORDEND", "debut": "2026-11-05T06:00Z", "fin": "2026-11-05T12:00Z"})`. Attendu : `"--agent"` suivi de `"agents:analyste"`, `"--plugin-dir"` dans les arguments, `"DETECTEURS : non" in prompt`, `"CONSIGNES : consignes/analyste.md" in prompt`. Puis, le fil fini (état `fini`) et `travail/session` écrit par le test, `analyse.message(nom, {"texte": "continue"})` relance avec `--resume`, `--plugin-dir` et `agents:analyste`.
- [ ] **Étape 2 : les voir échouer.** `.venv/bin/python app/serveur/check.py`.
Attendu : `check_analyse` et `check_optimisation` échouent sur leurs assertions nouvelles.
- [ ] **Étape 3 : les liens et les consignes.** `ln -s ~/tools tools`, `ln -s ~/agents agents`, `ln -s ~/Optimizer optimizer`, puis `.gitignore`. `consignes/analyste.md` reprend la part propre à l'app de l'ancien analyste : le contexte de la page Data (l. 9), ce qu'il reçoit et le dossier `labeling/auto/analyses/<STATION>_<début>_<fin>/` (l. 15), ne jamais écrire dans `labeling/auto/<STATION>.jsonl`, le serveur verse, le dialogue par la même session (l. 17-18), le rapport (l. 85-92), la réponse en 2 lignes (l. 94).
- [ ] **Étape 4 : `station.py`.** `sys.path` prend `RACINE / "tools"` à la place de `agent-tools` ; `TOOLS` ; `liens()` ajoute `TOOLS` ; la docstring dit `tools/donnees.py`.
- [ ] **Étape 5 : `analyse.py`.**
- `DEMANDE` finit par ` DETECTEURS : non. CONSIGNES : consignes/analyste.md.`
- `travailler` lance `"--plugin-dir", str(AGENTS), "--agent", "agents:analyste"` à la place de `"--agent", "analyste"`.
- `AMELIORER` devient la requête `/improve` de la tâche 4, chemins relatifs à la racine d'Optimizer, `CONTEXT: labeling/auto/analyses/{nom}/rapport.md`, `OUT: seances/{nom}_{heure}/`, contexte : `Caller's context: Diagnostic-app, through Optimizer; read-only on data/ and labeling/; commit only in detectors/, on its current branch; do not commit OUT.`
- `optimiser()` refuse (`station.Refus`) sans `OPTIMIZER/.claude/skills/improve/SKILL.md` ou sans `AGENTS/.claude-plugin/plugin.json`, avec le message « pas d'Optimizer en optimizer/ ou pas d'agents en agents/ (les liens : README.md) ».
- `optimiser_fil` : le premier tour se lance avec `cwd=OPTIMIZER.resolve()`, `--plugin-dir str(AGENTS.resolve())`, et `--add-dir` des cibles réelles de `detectors/` et de `station.liens()` ; le second avec `cwd=station.RACINE`, `--plugin-dir str(AGENTS)`, `--agent agents:tool-builder` et la requête `Analyse : {rel}/. Outils : tools/. Écris {rel}/outils.md.`.
- `_bilan(nom)` : `sorted(SEANCES.glob(f"{nom}_????????T????Z/summary.md"))`, le dernier.
- La docstring du module dit le nouveau montage.
- [ ] **Étape 6 : `Data.jsx`.** L'infobulle d'« Optimiser » : « Améliorer les détecteurs (Optimizer), puis les outils de lecture (tool-builder), depuis cette analyse » ; la commande affichée : `python3 detectors/bench/score.py …` ; le commentaire des l. 490-491 suit.
- [ ] **Étape 7 : les voir passer.** `.venv/bin/python app/serveur/check.py`.
Attendu : `ok check_serveur`, `ok check_station`, `ok check_optimisation`, `ok check_analyse`.
- [ ] **Étape 8 : retirer l'ancien.** `git rm -r agent-tools .claude/agents .claude/skills`, puis relancer `check.py` (toujours 4 `ok`) et `cd app/web && npm run build` (sans erreur).
- [ ] **Étape 9 : la doc.** README et CLAUDE.md : la responsabilité (« le poste de pilotage : voir, analyser, lancer ») ; les six liens et leur installation ; les deux boutons, chacun avec ce qu'il lance et où le code vit ; le benchmark par `python3 detectors/bench/regression.py --labels labeling/auto --data data` ; l'architecture (`docs/architecture.drawio`). `app/README.md:21-24, 40-41` suit les mêmes changements.
- [ ] **Étape 10 : commiter.** `git commit -m "Diagnostic-App, le poste de pilotage : l'analyste et le tool-builder du dépôt agents, l'optimisation par Optimizer, la lecture par tools" -- .gitignore consignes app agent-tools .claude README.md CLAUDE.md`.
### Task 6 : le labeler de labeling (à confirmer par l'utilisateur)
Le dépôt labeling porte la conception et le plan d'un « labeler » qui n'est pas construit : beaucoup d'étiquettes à faible effort, avec l'aide des détecteurs (`docs/superpowers/specs/2026-11-14-labeler-design.md`, `docs/superpowers/plans/2026-11-14-labeler.md`). Il n'est pas dans l'architecture validée.
- [ ] **Étape 1 :** sur la décision de l'utilisateur, soit `git mv docs/superpowers/{specs,plans}/2026-11-14-labeler* docs/archive/` avec une ligne dans `README.md`, et le commit « Le labeler archivé : hors de l'architecture du 2026-11-16 » ; soit rien.
### Task 7 : l'essai réel et la mise en ligne (sur l'accord de l'utilisateur)
- [ ] **Étape 1 : l'app.** Tâche VS Code « Run app », puis, dans la page Data, « Analyser la plage » sur une courte plage choisie par l'utilisateur. Attendu : le fil montre l'analyste lisant `tools/GUIDE.md`, puis `etiquettes.jsonl` et `rapport.md` dans `labeling/auto/analyses/<nom>/`.
- [ ] **Étape 2 : « Optimiser les détecteurs »** sur cette analyse. Attendu : `optimizer/seances/<nom>_<heure>/summary.md` affiché sous le rapport ; des commits `improve: S<n>` dans `~/detectors`, ou aucun ; un commit « Outils : … » dans `~/tools`, ou « aucun outil modifié » dans `<analyse>/outils.md`.
- [ ] **Étape 3 : la mémoire.** Mettre à jour `~/.claude/projects/-home-maxime-Support-Agent/memory/donnees-et-etiquettes-centralisees.md` (plus de plugin `/detectors:wf-improve` ; les liens `tools`, `agents`, `optimizer`) et `refonte-des-depots.md` (refonte faite).
- [ ] **Étape 4 : Gitea.** Avec l'accord de l'utilisateur : `gt repo create tools`, `gt repo create agents` (publics, comme les autres), `git remote add origin gitea@exchange.sensima.ch:maxime.pasquier/<dépôt>.git`, puis `git push` des sept dépôts touchés.
+27
View File
@@ -0,0 +1,27 @@
# Diagnostic-App's instructions to the analyst
What the app asks of the analyst (agents repository, `agents:analyst`), on top of its trade. Launched by the Analysis tab of the Data page (`app/server/analysis.py`), with `DETECTORS: no`.
## Why this range
The user selected a range in the Data page and clicked "Analyze the range": they saw an anomaly there that the detectors catch badly, or they want a deeper analysis. Their hints are in the request (or "none"). Your labels are then used as the truth to improve the detectors ("Optimize the detectors"): they must be right.
## Your output folder
`labeling/auto/analyses/<STATION>_<start>_<end>/`, given by the request; your work and claude's log in `work/`, outside git.
- Your labels go in `labels.jsonl`; the server is the one that submits them to `labeling/auto/<STATION>.jsonl`. **You never write in `labeling/auto/<STATION>.jsonl`.**
- Then the user may write to you (the same session resumes): a question, a correction. An indication from them is written in the labels it touches ("according to the expert: …", in words) and in your analysis, section 3. If you change your labels, rewrite `labels.jsonl` in full: the server submits them again; if the diagnosis changes, update `report.md`.
## The report
On top of your labels and your analysis: `report.md`, the diagnosis the user will read in the page, in English:
- `# <STATION>: <the subject in a few words>`, then the question (their selection, their hints) in one or two sentences;
- "What the data show": each event dated (UTC), the sensors affected and those that do not move, the cause and its level of evidence (confirmed / strongly supported / consistent with / possible / insufficient evidence / not observed), the command behind each fact;
- the figures that prove, each inserted by `![caption](path relative to the output folder)` and followed by a line that says what is seen in it: curves (`plot.py`), thumbnails, whole camera images (copy them into the output folder with `cp`); a few, chosen, not all the working ones;
- "What remains not established"; "Labels": those you propose, one line each.
## Your answer
In 2 lines: the number of labels, the path of the report.