diff --git a/.claude/rules/analyses.md b/.claude/rules/analyses.md index ba5b564..5348675 100644 --- a/.claude/rules/analyses.md +++ b/.claude/rules/analyses.md @@ -14,7 +14,7 @@ paths: - **Contrat commun** : - `run(series) -> {analysis, rule, points: [{t, value, anomaly, facts}]}` ; - calcul **causal** : le point t n'utilise que les données ≤ t ; - - `anomaly = None` signifie UNKNOWN (exception : `DAILY_BATTERY_STATE` en phase C, `DAILY_BATTERY_TREND`, `DAILY_LINK_STATE` et `DAILY_SIGNAL_STATE`, où `None` = pas de verdict ; l'UNKNOWN est dans `facts.state` ou `facts.trend`) ; + - `anomaly = None` signifie UNKNOWN (exception : `DAILY_BATTERY_STATE` en phase C, `DAILY_BATTERY_TREND`, `DAILY_LINK_STATE`, `DAILY_SIGNAL_STATE`, `DAILY_STORAGE_STATE` et `DAYS_UNTIL_STORAGE_FULL`, où `None` = pas de verdict ; l'UNKNOWN est dans `facts.state`, `facts.trend` ou `facts.filling`) ; - une analyse seule conclut au plus `consistent with`. - **Code de calcul** (`src//`) : bibliothèque standard uniquement et aucun import de `src/common/`, car il doit tourner sur la station. Plotly ne sert qu'aux graphiques, sur le poste de dev (`.venv`). Le chargement des CSV est dans `common.stations`. - **Constantes** : chacune a sa source, en commentaire dans le code et dans le tableau de la fiche. Aucun seuil sans source. diff --git a/.claude/skills/nouveau-domaine/SKILL.md b/.claude/skills/nouveau-domaine/SKILL.md index e79c8eb..fdb4f09 100644 --- a/.claude/skills/nouveau-domaine/SKILL.md +++ b/.claude/skills/nouveau-domaine/SKILL.md @@ -45,7 +45,7 @@ Un domaine reprend le travail fait pour Energy : des analyses sans LLM, un verdi - `src//day_color.py`, sur le modèle de `src/energy/day_color.py` : - `run(series) -> {analysis, rule, points}`, un point par jour UTC, causal, `anomaly = None`, la couleur dans `facts.color` : `GREEN`, `ORANGE`, `RED` ou `None` (inconnu, gris) ; - `HEADLINE = {"RED": "...", "ORANGE": "..."}` : une phrase en anglais par couleur notifiée (D-023). Green ne notifie rien (D-025). -- Ce que veut dire Red pour ce domaine, et la combinaison des analyses (une matrice tenue par l'utilisateur si elle est utile), se décident avec l'utilisateur. +- Ce que veut dire Red pour ce domaine, et la combinaison des analyses, se décident avec l'utilisateur. La combinaison se dessine en matrice dans `docs//matrice--.drawio`, tenue par l'utilisateur, et le code la recopie dans `MATRIX` (Energy, D-020 ; Storage, D-035). ## 7. Livrer et documenter diff --git a/CLAUDE.md b/CLAUDE.md index 65094e3..8ffe72f 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -14,9 +14,9 @@ L'état courant seulement ; l'historique est dans `git log` et `docs/decisions.m - **Energy, comparaison seulement** : les deux moyennes glissantes sur 7 jours. Point ouvert : l'accoutumance après ~30 jours de déficit (fiche `moving_average_7_days_drop`). - **Maquettes du site (D-022)** : client « Energy » (section Diagnostic de la page System Summary) ; support « Home » (section Status, une notification par station Orange ou Red, lien vers la vue client, D-025). - **Agents LLM côté serveur (D-027)** : rapport exploratoire seulement, rien n'est construit. -- **Storage (D-030)** : note de départ (`docs/storage/domaine/point-de-depart.md`), jeu de travail WEISSHORN ; aucune analyse. -- **Cellular (D-030 à D-032), en pause en attendant le spécialiste** : WEISSHORN (sans incident) et NORDEND (109 jours, 11 coupures de la liaison) explorés ; `DAILY_LINK_STATE` et `DAILY_SIGNAL_STATE` en prototype, sans cas de l'expert ; deux corrections de `DAILY_LINK_STATE` retenues sur le principe mais non codées ; ni couleur du jour, ni figure du site, ni maquette, ni guide (étapes 6 et 7 de `nouveau-domaine`). Reprise : `docs/cellular/domaine/questions-pour-l-expert.md`. -- **Prochaine étape** : `cellular` : l'utilisateur voit avec le spécialiste les questions de `docs/cellular/domaine/questions-pour-l-expert.md` (cadence des envois, articulation des deux corrections de `DAILY_LINK_STATE`, retenues mais non codées, cas annotés) ; ensuite les corrections, puis la couleur du jour (étape 6) ; explorer WEISSHORN pour `storage` (étape 3) ; domaine candidat : surchauffe (`sensor_*_deg_c`), à créer avec `nouveau-domaine` et repérer les autres champs à notifier ; étape 1 du rapport d'agents (pilote manuel Energy sur l'historique de VERMONT, il faut une clé API Anthropic) ; mise en forme du manuel avec le plugin Interactive Docs (dans une autre conversation) ; choisir avec l'équipe du site le format d'intégration du graphique ; maquettes : poursuivre « Energy » côté client pas à pas, puis le côté support pas à pas (points ouverts dans D-022). +- **Storage (D-030, D-034, D-035)** : jeu de travail WEISSHORN seul (NORDEND n'a pas les mesures de `/data`) ; `DAILY_STORAGE_STATE` et `DAYS_UNTIL_STORAGE_FULL` en prototype, sans cas de l'expert ; couleur du jour codée (`src/storage/day_color.py`, matrice état × horizon `docs/storage/matrice-etat-horizon.drawio`, la pire des deux) ; seuils arbitraires (20 % / 10 % libres, 60 / 14 jours) ; questions en suspens dans `docs/storage/domaine/questions-pour-l-expert.md` ; ni figure du site, ni maquette, ni guide (étape 7 de `nouveau-domaine`). +- **Cellular (D-030 à D-032), en pause en attendant le spécialiste** : WEISSHORN (mise en service le 19/08, puis quelques incidents isolés) et NORDEND (109 jours, 11 coupures de la liaison) explorés ; `DAILY_LINK_STATE` et `DAILY_SIGNAL_STATE` en prototype, sans cas de l'expert ; deux corrections de `DAILY_LINK_STATE` retenues sur le principe mais non codées ; ni couleur du jour, ni figure du site, ni maquette, ni guide (étapes 6 et 7 de `nouveau-domaine`). Reprise : `docs/cellular/domaine/questions-pour-l-expert.md`. +- **Prochaine étape** : `cellular` : l'utilisateur voit avec le spécialiste les questions de `docs/cellular/domaine/questions-pour-l-expert.md` (cadence des envois, articulation des deux corrections de `DAILY_LINK_STATE`, retenues mais non codées, cas annotés) ; ensuite les corrections, puis la couleur du jour (étape 6) ; `storage` : la livraison (étape 7 de `nouveau-domaine`, dans une autre conversation : figure du site `src/storage/final.py`, passage des maquettes à une liste de domaines, maquettes à proposer puis attendre les consignes, guide `docs/storage/guide/`) ; domaine candidat : surchauffe (`sensor_*_deg_c`), à créer avec `nouveau-domaine` et repérer les autres champs à notifier ; étape 1 du rapport d'agents (pilote manuel Energy sur l'historique de VERMONT, il faut une clé API Anthropic) ; mise en forme du manuel avec le plugin Interactive Docs (dans une autre conversation) ; choisir avec l'équipe du site le format d'intégration du graphique ; maquettes : poursuivre « Energy » côté client pas à pas, puis le côté support pas à pas (points ouverts dans D-022). ## Analyses (domaine Energy) @@ -32,7 +32,7 @@ Code dans `src/energy/`, fiche dans `docs/energy/analyses/ - **Couleur du jour** : `src/energy/day_color.py` (`MATRIX`, `focus()` pour J−1 / J), transcription de `docs/energy/matrice-etat-tendance.drawio`. - **Travailler sur une analyse** : `.claude/rules/analyses.md` (contrat `run(series)`, calcul causal, constantes sourcées, graphiques, fiche à jour) se charge seul dès qu'on touche `src/` ou `docs/*/analyses/`. - **Créer une analyse** : skill `nouvelle-analyse`. -- **Créer un domaine (une nouvelle notification)** : skill `nouveau-domaine` (D-030). Domaine en attente d'analyses : `storage` (espace disque). +- **Créer un domaine (une nouvelle notification)** : skill `nouveau-domaine` (D-030). ## Analyses (domaine Cellular) @@ -43,6 +43,17 @@ Code dans `src/cellular/`, fiche dans `docs/cellular/analyses/.md`, page de comparaison `src/storage/all_analyses.py` (WEISSHORN, D-034). + +| Règle | Question | Statut | Code | +|---|---|---|---| +| `DAILY_STORAGE_STATE` | Chaque jour : espace libre de `/data` en % de l'utilisable, `OK`, `LOW` ou `CRITICAL` (planchers arbitraires 20 % / 10 %) ? | prototype (D-034) | `storage_state.py` | +| `DAYS_UNTIL_STORAGE_FULL` | Chaque jour : dans combien de jours le disque sera-t-il plein, au rythme médian des 7 derniers jours ? | prototype (D-034) | `days_until_full.py` | + +- **Couleur du jour** : `src/storage/day_color.py` (`MATRIX[état][horizon]`, `HEADLINE`), transcription de `docs/storage/matrice-etat-horizon.drawio` (D-035). + ## Commandes ```bash @@ -50,6 +61,7 @@ python3 src/energy/final.py [données] # livré : out/_energy.html python3 src/energy/focus_jour.py JJ.MM[.AAAA] [données] # un jour et sa veille (D-024) : faits + out/_focus_.html + .json python3 src/cellular/all_analyses.py [données] # analyses 4G comparées : out/_cellular.html (défaut data/WEISSHORN/ et data/NORDEND/) +python3 src/storage/all_analyses.py [données] # analyses disque comparées : out/_storage.html (défaut data/WEISSHORN/) python3 maquettes/user/energy.py [début] [fin] # maquette client : out/maquette_user_energy.html python3 maquettes/support/home.py [début] [fin] # maquette support : out/maquette_support_home.html pdftotext -layout "docs/aimsight/.pdf" - # lire un PDF AIMsight @@ -72,7 +84,7 @@ python3 -m venv .venv && .venv/bin/pip install plotly # recréer .venv ### Fichiers - `README.md` (40 l) : point d'entrée pour un humain. -- `docs/decisions.md` (360 l, D-001 à D-033) : décisions **projet**, au format ADR allégé (statut, décision, pourquoi, options écartées, conséquence). À consulter avant de changer d'orientation ou de reproposer une option : elle a peut-être déjà été écartée. +- `docs/decisions.md` (380 l, D-001 à D-035) : décisions **projet**, au format ADR allégé (statut, décision, pourquoi, options écartées, conséquence). À consulter avant de changer d'orientation ou de reproposer une option : elle a peut-être déjà été écartée. - `docs/domaine/` : savoir métier commun, une note courte (< 50 l) par question. - `ce-que-mesure-la-station.md` : format CSV, métriques et unités, consommation mesurée mais pas l'apport. - `pieges-des-donnees.md` : trou ≠ coupure, signatures d'une coupure, seuils absolus, cycle jour/nuit. @@ -82,7 +94,7 @@ python3 -m venv .venv && .venv/bin/pip install plotly # recréer .venv - `domaine/` (< 80 l) : `comment-se-comporte-la-batterie.md` (LiFePO4, plateau et coude, table OCV, redémarrage à 12,6 V, capacité) ; `tensions-selon-l-etat-de-la-batterie.md` (tensions et pentes en charge, pleine charge et décharge) ; `cas-annotes-par-l-expert.md` (diagnostics experts des 5 stations, vérité de référence). - `guide/diagnostic-energetique.md` (180 l, brouillon) : manuel, partie 1 pour le client (§1-4), partie 2 pour le support (§5-9). À tenir à jour avec la matrice et les fiches des deux analyses livrées. - `matrice-etat-tendance.drawio` : matrice état × tendance, tenue par l'utilisateur. -- `docs/storage/`, `docs/cellular/` : domaines Storage (espace disque) et Cellular (signal 4G), D-030. Une note de départ chacun : `domaine/point-de-depart.md` (mesures du collecteur, données reçues, pièges, pistes) ; Cellular a aussi ses fiches dans `analyses/` et `domaine/questions-pour-l-expert.md` (questions ouvertes). +- `docs/storage/`, `docs/cellular/` : domaines Storage (espace disque) et Cellular (signal 4G), D-030. Storage a sa matrice état × horizon, `matrice-etat-horizon.drawio`, tenue par l'utilisateur. Chacun a une note de départ, `domaine/point-de-depart.md` (mesures du collecteur, données reçues, pièges, pistes), ses fiches dans `analyses/` et ses questions ouvertes dans `domaine/questions-pour-l-expert.md`. - `docs/agents/rapport-exploratoire.md` (290 l) : cadre d'agents LLM (D-027) : choix retenus, architecture, démarrage par étapes (§6) ; annexe A : pistes à revoir étape par étape. Le code d'agent vivra à part (`agents/`, proposé, pas créé). - `docs/aimsight/` : documentation AIMsight d'origine, en anglais, non modifiée. À lire avant de concevoir, **par section** ; ne pas re-demander à l'utilisateur ce qui y figure. - `AIMsight_reference_quality_event_explainer_roadmap.md` (1 180 l) : **référence qui fait autorité** : couche diagnostique commune, explainer d'événements, classifications (§4.3), API indépendante de l'estimateur (§10). @@ -93,14 +105,14 @@ python3 -m venv .venv && .venv/bin/pip install plotly # recréer .venv - `docs/superpowers/` : specs et plans superpowers (170-850 l chacun). Historique non maintenu, pas une référence. La spec d'une nouvelle analyse s'écrit dans sa fiche ; le plan peut aller dans `docs/superpowers/plans/`. - `data/` : un dossier par station (D-029). - `VERMONT/` : **jeu de travail = VERMONT seule** (D-009), le plus long historique : 7 CSV, un par métrique système (~5 000 l chacun). Les analyses Energy tournent uniquement sur ce jeu (défaut des scripts). - - `WEISSHORN/` : tous les champs de la caméra (export du 2026-10-13, 10 jours) ; jeu de travail de `storage` et `cellular` (D-030). Contient des identifiants (`SIM_CCID`, `ip`) : ne pas les recopier ; le dépôt doit rester privé (D-014). + - `WEISSHORN/` : tous les champs de la caméra (export du 2026-10-13, du 09/08 au 13/10, mesures dès le 19/08) ; jeu de travail de `storage` (seul, D-034) et `cellular` (D-030). Contient des identifiants (`SIM_CCID`, `ip`) : ne pas les recopier ; le dépôt doit rester privé (D-014). - `NORDEND/` : tous les champs d'une version plus ancienne du collecteur (export du 2026-10-13, 109 jours, sans `link`) ; deuxième jeu de travail de `cellular`, station à la liaison faible (D-032). Mêmes identifiants à ne pas recopier (`SIM_CCID`, `ip_*`). - Les notes brutes de l'expert (`metadata.md`, `d.md`) et `archive/` ont été retirées le 2026-10-13 (D-033) : leur résumé est dans `docs/energy/domaine/cas-annotes-par-l-expert.md`. - `src/` : un sous-dossier par domaine, plus le code commun (D-026). - `common/` : `stations.py` (chargement des CSV, métriques texte en listes, trous de mesure ; bibliothèque standard) et `page.py` (poste de dev : bascule `.venv`, ouverture dans le navigateur, `AUTOSCALE_Y_JS`). - `energy/` : calcul embarquable, en bibliothèque standard et sans import de `common/` : `battery_state.py`, `battery_trend.py`, `moving_average.py`, `day_color.py`. Scripts plotly du poste de dev, à laisser hors de la station : `final.py`, `all_analyses.py`, `focus_jour.py`. - `cellular/` : calcul embarquable `link_state.py`, `signal_state.py` ; page plotly `all_analyses.py` (D-031). - - `storage/` : vide (`__init__.py`), en attente de la première analyse (D-030). + - `storage/` : calcul embarquable `storage_state.py`, `days_until_full.py`, `day_color.py` (D-035) ; page plotly `all_analyses.py` (D-034). - `maquettes/` : maquettes du site en HTML sur données réelles (D-022), Figma seulement sur demande. Un script remplit son gabarit HTML : `user/energy.py` + `energy_template.html` (client), `support/home.py` + `home_template.html` (support). - `.claude/` : `rules/analyses.md` (se charge seule, voir « Analyses »), `skills/nouvelle-analyse/` (procédure et modèle de fiche), `skills/nouveau-domaine/` (procédure pour un nouveau domaine), `settings.json` (lecture de `.env` interdite). - `architecture.drawio` : schéma d'architecture tenu par l'utilisateur. Ne pas le modifier sans demande. diff --git a/README.md b/README.md index e7d9617..b9ac4cf 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ python3 src/energy/final.py Le script analyse `data/VERMONT/` et ouvre dans le navigateur `out/VERMONT_daily.html`, l'état et la tendance de la batterie jour par jour : ce sont les analyses livrées, destinées au site de monitoring. La figure Plotly est aussi écrite dans `out/VERMONT_daily.json`. -Pour comparer les quatre analyses Energy sur une même page (`out/VERMONT_energy.html`) : `python3 src/energy/all_analyses.py`. Pour comprendre la couleur d'un jour, en ne regardant que ce jour et la veille : `python3 src/energy/focus_jour.py 27.09`. +Pour comparer les quatre analyses Energy sur une même page (`out/VERMONT_energy.html`) : `python3 src/energy/all_analyses.py`. Pour comprendre la couleur d'un jour, en ne regardant que ce jour et la veille : `python3 src/energy/focus_jour.py 27.09`. Pages des autres domaines, sur WEISSHORN par défaut : `python3 src/storage/all_analyses.py` (espace disque) et `python3 src/cellular/all_analyses.py` (signal 4G). La page de comparaison se lit ainsi : - **en haut**, l'analyse ; @@ -26,12 +26,12 @@ Plotly est installé dans `.venv/`, et le script y bascule seul. Pour recréer c | Vue d'ensemble, règles du projet, commandes | `CLAUDE.md` | | Pourquoi le projet est comme il est (décisions, options écartées) | `docs/decisions.md` | | Lire le diagnostic énergétique (manuel client et support) | `docs/energy/guide/diagnostic-energetique.md` | -| Ce que fait chaque analyse, ses seuils et ses limites | `docs/energy/analyses/.md` | +| Ce que fait chaque analyse, ses seuils et ses limites | `docs//analyses/.md` | | Savoir métier (mesures, batterie, pièges des données, cas experts) | `docs/domaine/` (commun), `docs//domaine/` (`energy`, `storage`, `cellular`) | | Documentation AIMsight d'origine | `docs/aimsight/` | -| Données de travail (VERMONT pour Energy, WEISSHORN pour Storage et Cellular) et diagnostics experts | `data/VERMONT/`, `data/WEISSHORN/`, `data/` | +| Données de travail (VERMONT pour Energy, WEISSHORN pour Storage, WEISSHORN et NORDEND pour Cellular) | `data//` | | Maquettes du site, côté client (`user/`) et support (`support/`) ; ex. `python3 maquettes/user/energy.py`, `python3 maquettes/support/home.py` | `maquettes/` | ## État -Prototype expérimental, sans tests automatisés. Quatre analyses Energy sont en place. Deux sont livrées : `DAILY_BATTERY_STATE`, l'état de la batterie jour par jour, et `DAILY_BATTERY_TREND`, sa tendance d'un jour à l'autre. Les deux autres servent à la comparaison : `MOVING_AVERAGE_7_DAYS_DROP` et sa variante sur la seule mesure de 00:00 UTC. Les suivantes sont listées dans les fiches `docs/energy/analyses/` (section « Pistes »). Deux nouveaux domaines, Storage (espace disque) et Cellular (signal 4G), ont leur structure et attendent l'exploration des données de WEISSHORN ; le skill `nouveau-domaine` décrit comment ajouter un domaine (D-030). +Prototype expérimental, sans tests automatisés. Quatre analyses Energy sont en place. Deux sont livrées : `DAILY_BATTERY_STATE`, l'état de la batterie jour par jour, et `DAILY_BATTERY_TREND`, sa tendance d'un jour à l'autre. Les deux autres servent à la comparaison : `MOVING_AVERAGE_7_DAYS_DROP` et sa variante sur la seule mesure de 00:00 UTC. Les suivantes sont listées dans les fiches `docs/energy/analyses/` (section « Pistes »). Deux autres domaines sont en prototype, sans cas annotés par l'expert. Storage (espace disque) : `DAILY_STORAGE_STATE`, `DAYS_UNTIL_STORAGE_FULL` et leur couleur du jour, avec des seuils arbitraires pour commencer (D-034, D-035) ; reste la livraison. Cellular (signal 4G) : `DAILY_LINK_STATE` et `DAILY_SIGNAL_STATE`, en pause en attendant le spécialiste. Le skill `nouveau-domaine` décrit comment ajouter un domaine (D-030). diff --git a/docs/decisions.md b/docs/decisions.md index 4c8eaa1..18202e9 100644 --- a/docs/decisions.md +++ b/docs/decisions.md @@ -353,3 +353,25 @@ Règles du journal : - **Pourquoi** : choix de l'utilisateur. - **Options écartées** : les garder (refusé par l'utilisateur). - **Conséquence** : les fichiers restent dans l'historique git, identifiants compris. Le dépôt doit toujours rester privé (D-014) : les CSV de WEISSHORN et NORDEND contiennent aussi `SIM_CCID` et des adresses IP. Les specs et plans de `docs/superpowers/` (historique non maintenu) citent encore ces fichiers. + +## D-034 — 2026-10-13 — Storage : niveau du jour et jours avant saturation ; seuils arbitraires ; WEISSHORN seul +- **Statut** : active. Applique D-030 (domaine Storage) ; déroge à la règle « aucun seuil sans source » pour des seuils provisoires. +- **Décision** : + - deux analyses sans verdict (`anomaly = None`), codées avant les réponses de l'expert : `DAILY_STORAGE_STATE` (espace libre en fin de jour, en % de l'espace utilisable : `OK`, `LOW`, `CRITICAL`) et `DAYS_UNTIL_STORAGE_FULL` (espace libre ÷ médiane des consommations journalières sur 7 jours) ; + - planchers de `DAILY_STORAGE_STATE` **arbitraires**, pour commencer : 20 % et 10 % libres. Ils sont marqués comme tels dans la fiche et dans le code ; + - le jeu de travail reste **WEISSHORN seul** : NORDEND n'a pas les mesures de `/data` (`*_disk_1k-blk`, plat pendant 104 jours). Les analyses ne lisent que `data_storage_*` ; + - les questions à l'expert (disque plein, purge, `root`, seuils, cas) restent en suspens dans `docs/storage/domaine/questions-pour-l-expert.md`. +- **Pourquoi** : choix de l'utilisateur, qui veut notifier un disque bientôt plein et estimer le temps restant, sans attendre l'expert. Le remplissage de WEISSHORN est assez régulier (28,2 MiB par jour, à l'heure près) pour une première estimation. +- **Options écartées** : ajouter NORDEND au jeu de travail (pas de données de `/data`) ; attendre l'expert avant de coder ; une régression linéaire ou une différence sur 7 jours pour le rythme (sensibles à une purge, fiche `days_until_storage_full`). +- **Conséquence** : la couleur du jour (étape 6 de `nouveau-domaine`) reste à décider ; LOW et CRITICAL ne sont jamais observés sur WEISSHORN (57 % libre au 13/10, saturation estimée au 06/02/2027). + +## D-035 — 2026-10-13 — Storage : couleur du jour, matrice état × horizon ; seuils de jours arbitraires +- **Statut** : active. Applique le contrat de notification de D-030 au domaine Storage ; complète D-034. +- **Décision** : + - `src/storage/day_color.py` : la couleur du jour se lit dans une matrice état × horizon, tenue par l'utilisateur dans `docs/storage/matrice-etat-horizon.drawio` et recopiée dans `MATRIX`, comme pour Energy (D-020). L'état vient de `DAILY_STORAGE_STATE` (`OK`, `LOW`, `CRITICAL`) ; l'horizon de `DAYS_UNTIL_STORAGE_FULL` : `WITHIN_14_DAYS`, `WITHIN_60_DAYS`, `BEYOND_60_DAYS` (60 jours ou plus, ou le disque ne se remplit pas), ou inconnu ; + - la matrice actuelle revient à prendre la pire des deux analyses. Orange ou Red peut venir d'une seule ; Green demande les deux, sinon le jour est gris (inconnu) ; + - seuils de jours **arbitraires** (14 et 60 jours), choix de l'utilisateur pour commencer, comme les planchers de D-034 ; + - `HEADLINE` : Red « The station is about to run out of storage space. », Orange « The station's storage space is running low. ». +- **Pourquoi** : choix de l'utilisateur, une matrice dessinée comme celle d'Energy. Les deux analyses voient des risques différents : le niveau voit un bloc ponctuel que l'estimation ne prévoit pas (1,3 GiB écrits en deux heures le 31/08 sur WEISSHORN) ; l'estimation voit un disque qui fond, même à un niveau encore confortable. +- **Options écartées** : le gris dès qu'une analyse manque, comme Energy (il cacherait un disque `CRITICAL` dont l'estimation n'est pas encore possible) ; le Green sur le seul niveau (il ignorerait un remplissage rapide pas encore mesuré). +- **Conséquence** : sur WEISSHORN, 52 jours Green et 14 gris (début d'historique jusqu'au 22/08, moins de 4 rythmes dans la fenêtre). Au rythme actuel, la station passerait Orange vers le 09/12 et Red vers le 17/01 (`CRITICAL`). La livraison (étape 7 : figure du site, maquettes, guide, passage des maquettes à une liste de domaines) se fera dans une autre conversation. diff --git a/docs/storage/analyses/daily_storage_state.md b/docs/storage/analyses/daily_storage_state.md new file mode 100644 index 0000000..f1db84c --- /dev/null +++ b/docs/storage/analyses/daily_storage_state.md @@ -0,0 +1,79 @@ +# `DAILY_STORAGE_STATE` : espace libre du disque en fin de jour + +- **Statut** : prototype en place (2026-10-13). État seul, sans verdict ; seuils arbitraires (D-034) ; pas encore de cas annotés par l'expert. +- **Script** : premier panneau de `python3 src/storage/all_analyses.py [CSV ou dossiers]` (défaut : `data/WEISSHORN/`), qui écrit `out/_storage.html` et l'ouvre. +- **Code** : `src/storage/storage_state.py` (`run()`, `day_facts()`), bibliothèque standard uniquement, sans import du projet. + +## Question posée + +Chaque jour, combien d'espace reste-t-il sur la partition `/data`, et est-ce encore confortable, bas ou critique ? + +- **Lien avec la question du domaine** : c'est la moitié « bientôt plein » de la notification. Le niveau seul ne dit pas quand le disque sera plein : c'est `DAYS_UNTIL_STORAGE_FULL`. +- **En pourcentage** : la taille de la partition change d'une station à l'autre (3,67 et 5,98 GiB, `docs/storage/domaine/point-de-depart.md`). Un seuil en GiB ne se transposerait pas. + +## Principe + +On prend la dernière mesure du jour et on classe la part d'espace libre sur deux planchers. + +Calcul exact, pour chaque jour UTC d : +1. Dernière heure de d où `data_storage_free_gb` et `data_storage_used_gb` sont mesurés et finis → `measured_at`. S'il n'y en a pas, `state` = `None` (UNKNOWN). +2. `usable_gb` = libre + utilisé : l'espace utilisable sans la réserve de `root`, comme le `percent` de `psutil`. +3. `free_percent` = 100 × libre / `usable_gb`, soit 100 − `data_storage_percent` du collecteur. +4. `state` = `OK` si `free_percent` ≥ 20, `LOW` s'il est ≥ 10, sinon `CRITICAL`. + +Une seule mesure suffit : l'espace libre est un niveau, pas une statistique du jour (pas de couverture minimale). + +Sortie (contrat commun) : un point par jour. +- `t` = dernière heure du jour présente dans la série. +- `value` = `free_percent`, en % (`None` si UNKNOWN). +- `anomaly` = `None` : état seul, sans verdict. L'état est dans `facts.state`. +- `facts` = `state`, `free_gb`, `free_percent`, `usable_gb`, `measured_at`. + +## Constantes et sources + +| Constante | Valeur | Source | +|---|---|---| +| `FREE_PERCENT_FLOORS` | 20 % (plancher de `OK`), 10 % (plancher de `LOW`) | **Choix arbitraire de l'utilisateur**, pour commencer (2026-10-13, D-034) ; ni la doc AIMsight ni le collecteur n'en donnent. À revoir avec l'expert (`docs/storage/domaine/questions-pour-l-expert.md`). | + +## Graphique + +- **En haut** : `free_percent` jour par jour (ligne), les deux planchers en pointillés, l'état en marqueurs (couleur et symbole). Le survol donne tous les faits. +- **Dessous** : `data_storage_free_gb`, `data_storage_used_gb`, `data_storage_total_gb`, en GiB. + +## Résultats (jeu de travail : WEISSHORN, export de 65 jours) + +- 09/08 au 18/08 : UNKNOWN (début d'historique, aucune mesure). +- 19/08 au 30/08 : `OK`, 99,94 à 99,69 % libre : disque presque vide, mise en service. +- 31/08 : `OK`, 76,66 % libre. Un bloc de 1,3 GiB écrit entre 13:00 et 15:00 UTC fait perdre 23 points en deux heures. +- 01/09 au 13/10 : `OK`, de 76,53 % à 56,67 % libre (3,20 GiB sur 5,65 GiB utilisables le 13/10). +- Les jours coupés par l'export ou par un trou (19/08, 20/08, 13/10) ont un état : une mesure suffit. +- Au rythme mesuré par `DAYS_UNTIL_STORAGE_FULL` (28,18 MiB/jour), WEISSHORN passerait `LOW` vers le 27/12/2026 et `CRITICAL` vers le 17/01/2027 (projection, pas une observation). +- `LOW` et `CRITICAL` ne sont donc jamais observés. Aucun cas annoté par l'expert. + +## Options écartées + +| Option | Pourquoi écartée | +|---|---| +| Seuil en GiB | Les partitions n'ont pas la même taille d'une station à l'autre. | +| Pourcentage du total, réserve de `root` comprise | Cette réserve n'est pas accessible à un utilisateur ordinaire ; `psutil` la retire aussi. | +| Couverture minimale du jour (comme `DAILY_SIGNAL_STATE`) | Le niveau d'un disque ne se moyenne pas : la dernière mesure est l'état le plus récent. | +| Minimum du jour | Égal à la dernière mesure sur un disque qui se remplit ; après une purge dans la journée, c'est la dernière mesure qui est juste. | +| `*_disk_1k-blk` (NORDEND, version plus ancienne du collecteur) | Partition plate pendant 104 jours, pas celle des mesures : choix de l'utilisateur (D-034). | + +## Limites connues + +1. **Seuils arbitraires** (D-034). +2. **Réserve de `root`** (5,4 % du total sur WEISSHORN) : si le logiciel d'acquisition tourne en `root`, il peut encore écrire à 0 % libre. +3. **Un niveau ne dit pas l'urgence** : 15 % libres sur un disque qui ne se remplit pas ne pressent pas ; 30 % qui fondent en une semaine, si. C'est le rôle de `DAYS_UNTIL_STORAGE_FULL`. +4. **Une seule station, jamais sous 56 % libre** ; aucun cas annoté. +5. **Une mesure par jour compte, la dernière** : un bloc écrit puis effacé dans la journée n'apparaît pas. + +## Pistes + +- Des seuils de l'expert, peut-être différents par taille de partition. + +## Historique + +- **2026-10-13** : création (D-034). +- **2026-10-13** : résultats sur l'export de 65 jours de WEISSHORN (09/08-13/10), qui remplace celui de 10 jours. +- **2026-10-13** : combinée à l'autre analyse Storage dans la couleur du jour, matrice état × horizon (`docs/storage/matrice-etat-horizon.drawio`, colonnes ; D-035). diff --git a/docs/storage/analyses/days_until_storage_full.md b/docs/storage/analyses/days_until_storage_full.md new file mode 100644 index 0000000..2d663d4 --- /dev/null +++ b/docs/storage/analyses/days_until_storage_full.md @@ -0,0 +1,81 @@ +# `DAYS_UNTIL_STORAGE_FULL` : jours avant que le disque soit plein + +- **Statut** : prototype en place (2026-10-13). Estimation seule, sans verdict ; pas encore de cas annotés par l'expert. +- **Script** : deuxième panneau de `python3 src/storage/all_analyses.py [CSV ou dossiers]` (défaut : `data/WEISSHORN/`), qui écrit `out/_storage.html` et l'ouvre. +- **Code** : `src/storage/days_until_full.py` (`run()`), bibliothèque standard uniquement ; reprend les fins de jour de `DAILY_STORAGE_STATE` (`src/storage/storage_state.py`). + +## Question posée + +Chaque jour, au rythme de remplissage des 7 derniers jours, dans combien de jours l'espace libre de `/data` atteindra-t-il 0 ? + +- **Lien avec la question du domaine** : c'est la moitié « pour combien de temps » de la notification. `DAILY_STORAGE_STATE` dit le niveau ; celle-ci dit l'urgence, que le disque soit grand ou petit. +- **Une estimation, pas une prévision** : elle suppose que le rythme récent continue. + +## Principe + +Le rythme de remplissage est la médiane des consommations journalières sur 7 jours ; les jours restants sont l'espace libre divisé par ce rythme. + +Calcul exact, pour chaque jour UTC d : +1. Fin de jour mesurée : `measured_at` de `DAILY_STORAGE_STATE` (dernière heure de d où libre et utilisé sont mesurés). La valeur de l'espace libre se relit dans la série, non arrondie. +2. Rythme du jour r(d) = (libre à la fin de jour mesurée précédente − libre à `measured_at`) / durée entre les deux, en jours. Positif : le disque se remplit. La division par la durée ramène à un jour un jour coupé par l'export ou un trou de plusieurs jours. +3. Fenêtre : les r des jours d−6 à d. Si d n'a pas de mesure, ou si la fenêtre compte moins de `MIN_RATES` rythmes : `filling` = `None` (UNKNOWN). +4. `rate` = médiane de la fenêtre. Une purge isolée (un r très négatif) ne la déplace pas. +5. Si `rate` ≤ 0 : `filling` = `False`, pas d'estimation. Sinon `filling` = `True`, `days_until_full` = libre / `rate`, `full_date` = `measured_at` + `days_until_full`. + +Sortie (contrat commun) : un point par jour. +- `t` = dernière heure du jour présente dans la série. +- `value` = `days_until_full`, en jours (`None` si UNKNOWN ou si le disque ne se remplit pas). +- `anomaly` = `None` : estimation seule, sans verdict. +- `facts` = `filling`, `fill_rate_mib_per_day`, `days_until_full`, `full_date`, `free_gb`, `rates` (nombre de rythmes dans la fenêtre). + +## Constantes et sources + +| Constante | Valeur | Source | +|---|---|---| +| `WINDOW_DAYS` | 7 jours | Principe du projet : fenêtres de plusieurs jours, multiples de 24 h (`CLAUDE.md`), comme les moyennes glissantes d'Energy. | +| `MIN_RATES` | 4 | Choix de conception : plus de la moitié de la fenêtre, pour que la médiane ne dépende pas d'un seul jour. | + +## Graphique + +- **En haut** : `days_until_full` jour par jour ; le survol donne le rythme, la date estimée et le nombre de rythmes. +- **Dessous** : les séries du disque (panneau commun avec `DAILY_STORAGE_STATE`). + +## Résultats (jeu de travail : WEISSHORN, export de 65 jours) + +- 09/08 au 22/08 : UNKNOWN (début d'historique, puis moins de 4 rythmes dans la fenêtre). +- 23/08 : `filling` = `True`, 0,74 MiB/jour, 7 798 jours (2047) : écritures de la mise en service, sans conséquence. +- 24/08 au 02/09 : `filling` = `False`, rythme médian nul : pas d'acquisition. **Le bloc de 1,3 GiB du 31/08 ne déplace pas la médiane** : ni estimation affolée, ni fausse alerte. +- 03/09 : 7,41 MiB/jour, 593 jours ; 04/09 : 9,99 MiB/jour, 437 jours. Le remplissage régulier commence le 03/09 ; la médiane le rejoint le 05/09, en 3 jours au lieu de 4, parce que le bloc du 31/08 est au-dessus. +- 05/09 au 13/10 : rythme médian de 28,17 à 28,18 MiB/jour ; 153,9 jours restants le 05/09, puis un de moins chaque jour, 116,5 le 13/10. **Date estimée stable pendant 39 jours : 06/02/2027.** +- Les jours atypiques (29,16 MiB le 12/10, le 13/10 coupé par l'export) sont écartés par la médiane. +- Aucune purge en 55 jours : la robustesse de la médiane à une purge n'est éprouvée qu'à l'envers, sur le bloc du 31/08. Aucun cas annoté. + +## Options écartées + +| Option | Pourquoi écartée | +|---|---| +| Régression linéaire sur les mesures horaires | Tirée par une purge ; plus de calcul pour un remplissage déjà linéaire. | +| Différence sur 7 jours, (libre(d−7) − libre(d)) / 7 | Une purge dans la fenêtre donne un rythme négatif pendant 7 jours. | +| Fenêtre de 30 jours | Suit un changement de régime en 16 jours au lieu de 4 ; WEISSHORN n'a qu'un seul régime à suivre (40 jours). | +| `*_disk_1k-blk` (NORDEND) | Partition plate pendant 104 jours, pas celle des mesures (D-034). | + +## Limites connues + +1. **Projection linéaire** : un changement de schedule (plus d'images, autre cadence) change le rythme ; il faut 4 jours pour qu'il domine la médiane (3 sur WEISSHORN le 05/09). +2. **Un bloc ponctuel n'est pas prévu** : le 31/08, 1,3 GiB sont écrits en deux heures. Sur un disque à moins de 1,3 GiB libre, il l'aurait rempli sans que l'estimation ne bouge ; seul `DAILY_STORAGE_STATE` le voit, le jour même. +3. **Purge automatique inconnue** : si la station efface ses plus vieilles données quand le disque est plein, « plein » n'arrive jamais. Question à l'expert. +4. **Réserve de `root`** : si l'acquisition tourne en `root`, elle peut écrire au-delà de 0 libre (5,4 % du total sur WEISSHORN). +5. **Un disque qui ne se remplit pas** (`filling = False`) n'a pas d'estimation ; son niveau reste suivi par `DAILY_STORAGE_STATE`. +6. **Une seule station** ; aucun cas annoté. + +## Pistes + +- Les purges : repérer les hausses de l'espace libre (aucune observée). +- Une fourchette de dates, à partir du rythme minimal et maximal de la fenêtre. +- Comparer le rythme au passé de la station, pour signaler un changement de schedule. + +## Historique + +- **2026-10-13** : création (D-034). +- **2026-10-13** : résultats sur l'export de 65 jours de WEISSHORN (09/08-13/10), qui remplace celui de 10 jours. +- **2026-10-13** : combinée à l'autre analyse Storage dans la couleur du jour, matrice état × horizon (`docs/storage/matrice-etat-horizon.drawio`, lignes ; D-035). diff --git a/docs/storage/domaine/point-de-depart.md b/docs/storage/domaine/point-de-depart.md index 8a8d175..b207767 100644 --- a/docs/storage/domaine/point-de-depart.md +++ b/docs/storage/domaine/point-de-depart.md @@ -24,7 +24,15 @@ Source : `docs/aimsight/collecteur_system_info.py`, `get_proc_info` et `SYNC_SPE - **Instantanés** (notes de l'expert du 2026-10-09, retirées du dépôt, D-033) : - WILDSTRUBEL : total 5,98, libre 5,61, utilisé 0,04 GiB ; - VERMONT expose d'autres noms, absents de notre copie du collecteur : `total_disk_1k-blk` (3 849 952), `used_disk_1k-blk` (2 829 916) et `avail_disk_1k-blk` (793 940), en blocs de 1 kio, ainsi que `DB_file_size`, `DB_total_entries`, `DB_uploaded`, `DB_not_uploaded`. -- **WEISSHORN** (`data/WEISSHORN/`, export du 2026-10-13, du 03/10 07:00 au 13/10 07:00 UTC, moyennes horaires) : libre de 3,21 à 3,48 GiB, utilisé de 2,17 à 2,45 GiB, total 5,98 GiB. +- **WEISSHORN** (`data/WEISSHORN/`, export du 2026-10-13, du 09/08 10:00 au 13/10 10:00 UTC, moyennes horaires) : total 5,98 GiB. Aucune mesure avant le 19/08 09:00, puis deux trous le 19-20/08 : début d'historique, sur tous les champs, `BusVoltage` compris. Plus aucun trou ensuite. Trois régimes : + - **19/08 au 30/08, disque presque vide** : 3,8 MiB utilisés le 19/08, 99,7 % libre. Quelques écritures le 21 et le 22/08 (13 et 1,5 MiB), puis rien du 23 au 30/08 : pas d'acquisition. + - **31/08, un bloc de 1,3 GiB** : −1 334 MiB entre 13:00 et 15:00 UTC (−681,6 puis −652,0 MiB), de 99,7 % à 76,7 % libre en deux heures. Origine inconnue (question à l'expert). + - **Dès le 03/09, remplissage linéaire** : −1,17 MiB par heure, à toutes les heures UTC (pas de cycle jour/nuit), soit 28,15 à 28,20 MiB par jour, 40 jours de suite (seule exception, 29,16 le 12/10). Les 01 et 02/09 sont une montée (7,4 et 10,0 MiB). + - **Aucune purge en 55 jours** : les hausses de l'espace libre ne dépassent pas +16,5 MiB (22/08, installation) et suivent une baisse plus forte d'une heure (fichiers temporaires). + - À ce rythme, les 3,20 GiB libres du 13/10 tiennent ~116 jours, jusqu'au 06/02/2027 : date stable depuis le 05/09. +- **NORDEND** (`data/NORDEND/`, 109 jours, `*_disk_1k-blk`, ÷ 1024² pour des GiB) : total 3,67 GiB, libre **0,62 GiB, constant à l'octet du 01/07 au 13/10** (104 jours). Seuls mouvements : +207,7 MiB le 29/06 à 11 h et −145,9 MiB le 01/07 (mise en service). La partition mesurée ne reçoit donc pas les mesures, ou celles-ci vont dans un fichier de taille fixe : `DB_file_size` vaut 2 097 152 kB (2 GiB) partout. + - Les 12 trous (début d'historique, puis 1 à 23 h) touchent tous les champs à la fois, `BusVoltage` compris : ce sont des trous de transmission (coupures de la liaison, domaine `cellular`), pas des pannes de disque. + - `DB_total_entries` = `DB_not_uploaded` à chaque heure : des entrées en attente d'envoi, nulles 95 % du temps ; trois épisodes forts (972 le 09-12/07, 322 le 01-02/08, 230 le 22-23/08) encadrent des trous de transmission. Ils relèvent plutôt de la communication que du disque. ## Ce qu'en dit la doc AIMsight @@ -33,20 +41,22 @@ Source : `docs/aimsight/collecteur_system_info.py`, `get_proc_info` et `SYNC_SPE ## Pièges connus -- **Utilisé + libre ≠ total** : 5,65 contre 5,98 GiB chez WILDSTRUBEL ; 3,46 contre 3,67 GiB chez VERMONT. Un écart de 5 à 6 % est cohérent avec les blocs réservés d'ext4, mais ce n'est pas vérifié. Le pourcentage de `psutil` se calcule sans eux. +- **Utilisé + libre ≠ total** : 5,65 contre 5,98 GiB chez WILDSTRUBEL et WEISSHORN ; 3,46 contre 3,67 GiB chez VERMONT et NORDEND. Chez WEISSHORN, utilisé + libre reste à 5,6548 GiB à l'octet pendant 55 jours : l'écart (0,32 GiB, 5,4 %) est une réserve fixe, pas une consommation. C'est la réserve de `root` : pour `psutil`, `free` est l'espace accessible à un utilisateur ordinaire (`f_bavail`), `used` = total − espace libre pour `root` (`f_bfree`). Si le logiciel d'acquisition tourne en `root`, il peut encore écrire quand `free` atteint 0 : question ouverte. - **Deux familles de métriques** : `data_storage_*` (WEISSHORN, WILDSTRUBEL) et `*_disk_1k-blk` (VERMONT), selon la version du logiciel ou la partition mesurée. Laquelle vaut pour chaque station : question ouverte. - **Les totaux diffèrent** d'une station à l'autre (3,67 et 5,98 GiB, peut-être pas la même partition) : raisonner en espace libre et en vitesse de remplissage, pas sur un pourcentage fixe. - Un trou de mesure pendant une coupure d'énergie n'est pas un problème de disque : croiser avec Energy. ## CSV reçus et manquants -- Reçus (WEISSHORN) : `data_storage_free_gb`, `data_storage_used_gb`, `data_storage_total_gb`. +- Reçus (WEISSHORN) : `data_storage_free_gb`, `data_storage_used_gb`, `data_storage_total_gb`. L'export de 65 jours remplace celui de 10 jours (03-13/10), qu'il contient ; il n'a plus `Battery Voltage`. - Reçus (NORDEND, autre version du collecteur, D-032) : `avail_disk_1k-blk`, `used_disk_1k-blk`, `total_disk_1k-blk` (blocs de 1 kB ; total constant de 3 849 952) ; `DB_file_size` (texte, `2097152kB`), `DB_total_entries`, `DB_uploaded` (toujours 0), `DB_not_uploaded` (0 à 972) : sens à confirmer. - Manquants : `data_storage_percent` (calculable à partir des deux premiers), et les métriques `DB_*` de VERMONT (base locale, envois en attente). -- L'export couvre 10 jours : assez pour l'état du jour, court pour une vitesse de remplissage. Un historique plus long le remplacera. +- L'export de WEISSHORN montre une mise en service et un démarrage d'acquisition, mais ni purge ni changement de schedule. +- Aucun des deux exports ne montre de disque plein ni de purge : il faut un cas de l'expert. -## Pistes d'analyses (non décidées) +## Analyses -- L'espace libre du jour. -- La vitesse de remplissage et les jours avant saturation (espace libre ÷ pente sur plusieurs jours). -- Les purges : sauts de l'espace libre vers le haut. +- En place (D-034) : `DAILY_STORAGE_STATE` (espace libre du jour) et `DAYS_UNTIL_STORAGE_FULL` (jours avant saturation), fiches dans `docs/storage/analyses/`. +- Couleur du jour (D-035) : matrice état × horizon, `docs/storage/matrice-etat-horizon.drawio`, recopiée dans `src/storage/day_color.py`. +- Piste : les purges, sauts de l'espace libre vers le haut (aucun observé). +- Questions en suspens : `questions-pour-l-expert.md`. diff --git a/docs/storage/domaine/questions-pour-l-expert.md b/docs/storage/domaine/questions-pour-l-expert.md new file mode 100644 index 0000000..99c9bd6 --- /dev/null +++ b/docs/storage/domaine/questions-pour-l-expert.md @@ -0,0 +1,26 @@ +# Storage : questions pour l'expert + +Questions ouvertes du domaine `storage`, en suspens au 2026-10-13. Chaque réponse va à sa place (note de départ, fiche, `cas-annotes-par-l-expert.md`), puis la question sort de cette liste. + +## Disque plein + +1. Que se passe-t-il quand `/data` est plein : l'acquisition s'arrête, ou les plus vieilles données sont effacées ? +2. Y a-t-il une purge ou une rotation automatique sur `/data` ? Sur WEISSHORN, aucune en 10 jours. +3. Le logiciel d'acquisition tourne-t-il en `root` ? Si oui, il peut encore écrire dans la réserve de `root` (5,4 % du total sur WEISSHORN) quand `free` atteint 0. + +## Seuils (`DAILY_STORAGE_STATE`, couleur du jour) + +4. À partir de combien d'espace libre (en % ou en jours restants) faut-il prévenir ? Les seuils actuels sont arbitraires (D-034, D-035) : 20 % et 10 % libres ; plein dans moins de 60 jours (Orange) ou de 14 jours (Red). +5. Combien de jours faut-il au support pour intervenir : nettoyage à distance, ou visite sur site ? + +## Cas de référence (étape 4 de `nouveau-domaine`) + +6. Une station est-elle déjà tombée à court de disque ? Avec ses dates, elle servirait de cas de référence. +7. Le rythme de WEISSHORN (28 MiB par jour, régulier à l'heure près, depuis le 03/09) correspond-il à son schedule ? +8. WEISSHORN, 31/08 entre 13:00 et 15:00 UTC : 1,3 GiB écrits d'un bloc sur `/data`. Qu'est-ce que c'est (mise à jour, images de référence, import de données) ? Un tel bloc peut-il revenir ? +9. WEISSHORN, 19/08 au 02/09 : disque presque vide et pas d'acquisition du 23 au 30/08. Mise en service ? + +## Champs des versions plus anciennes du collecteur + +10. Quelle partition mesurent `*_disk_1k-blk` (NORDEND, VERMONT) ? Chez NORDEND, l'espace libre est constant à l'octet pendant 104 jours. +11. `DB_file_size` (2 GiB fixe chez NORDEND) : base préallouée ? Où vont les mesures sur ces stations ? diff --git a/docs/storage/matrice-etat-horizon.drawio b/docs/storage/matrice-etat-horizon.drawio new file mode 100644 index 0000000..9322421 --- /dev/null +++ b/docs/storage/matrice-etat-horizon.drawio @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/storage/all_analyses.py b/src/storage/all_analyses.py new file mode 100644 index 0000000..6958e62 --- /dev/null +++ b/src/storage/all_analyses.py @@ -0,0 +1,78 @@ +"""Les analyses Storage ensemble, pour les comparer (D-016) : les panneaux des analyses, puis un graphique par série. + +Usage : python3 src/storage/all_analyses.py [CSV ou dossiers...] (défaut : data/WEISSHORN/) +Écrit out/_storage.html et l'ouvre. Documentation : docs/storage/analyses/ (une fiche par analyse) +""" +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) # src/ : paquets common, energy, cellular et storage +from common.page import AUTOSCALE_Y_JS, ROOT, open_html # noqa: E402 (bascule seule sur .venv si plotly manque) +from common.stations import gaps, load_stations # noqa: E402 +from plotly.subplots import make_subplots # noqa: E402 +from cellular.all_analyses import GRAY, hover, state_markers # noqa: E402 (mêmes marqueurs que Cellular) +from energy.final import noon # noqa: E402 (points journaliers à midi UTC, D-019) +from storage import days_until_full as du, storage_state as ss # noqa: E402 + +# Couleurs de la page Cellular, validées par le skill dataviz. +STATE_STYLE = {"OK": ("#008300", "circle"), "LOW": ("#eda100", "diamond"), "CRITICAL": ("#4a3aa7", "x"), None: GRAY} +METRICS = ["data_storage_free_gb", "data_storage_used_gb", "data_storage_total_gb"] + + +def figure(station, series, state, days): + titles = [f"Analyse {ss.RULE['id']}", f"Analyse {du.RULE['id']}"] + fig = make_subplots(rows=len(titles) + len(METRICS), cols=1, shared_xaxes=True, vertical_spacing=0.04, + subplot_titles=titles + METRICS) + group = dict(legendgroup=ss.RULE["id"], legendgrouptitle_text=f"Analyse {ss.RULE['id']}") + pts = state["points"] + x = [noon(p["t"].date()) for p in pts] + fig.add_scatter(x=x, y=[p["value"] for p in pts], name="espace libre du jour", mode="lines", + line=dict(color="#52514e", width=1.5), hoverinfo="skip", row=1, col=1, **group) + # Planchers tracés comme des courbes (un point par jour) : AUTOSCALE_Y_JS les garde visibles au zoom (D-013). + for f, s in zip(ss.FREE_PERCENT_FLOORS, ss.STATES): + fig.add_scatter(x=x, y=[f] * len(x), name=f"plancher {s} {f} %", mode="lines", hoverinfo="skip", + line=dict(color=STATE_STYLE[s][0], dash="dash", width=1), row=1, col=1, **group) + state_markers(fig, pts, "free_percent", "state", STATE_STYLE, 1, group) + fig.update_yaxes(title_text="libre / utilisable [%]", row=1, col=1) + + pts = [p for p in days["points"] if p["value"] is not None] + fig.add_scatter(x=[noon(p["t"].date()) for p in pts], y=[p["value"] for p in pts], name="jours avant saturation", + mode="lines+markers", text=[hover(p) for p in pts], hovertemplate="%{text}", + line=dict(color="#2a78d6", width=1.5), legendgroup=du.RULE["id"], + legendgrouptitle_text=f"Analyse {du.RULE['id']}", row=2, col=1) + fig.update_yaxes(title_text="jours restants", row=2, col=1) + + mesures = dict(legendgroup="mesures", legendgrouptitle_text="Mesures") + for row, m in enumerate(METRICS, start=len(titles) + 1): + s = series[m] + fig.add_scatter(x=sorted(s), y=[s[t] for t in sorted(s)], name=m, line=dict(width=1), row=row, col=1, + **mesures) + for a, b in gaps(s): + fig.add_vrect(x0=a, x1=b, fillcolor="gray", opacity=0.3, line_width=0, row=row, col=1) + fig.update_yaxes(title_text="GiB", row=row, col=1) + fig.update_xaxes(showticklabels=True) # dates sous chaque graphique, pas seulement le dernier + fig.update_yaxes(fixedrange=True) # zoom horizontal seulement : l'ordonnée est recalée par AUTOSCALE_Y_JS + fig.update_layout(title=f"{station} : analyses {ss.RULE['id']}, {du.RULE['id']}", height=300 * row, + legend=dict(groupclick="toggleitem")) + return fig + + +def main(paths): + """Pour chaque station qui a les mesures du disque : out/_storage.html. -> chemins écrits.""" + (ROOT / "out").mkdir(exist_ok=True) + written = [] + for station, series in sorted(load_stations(paths).items()): + if not set(METRICS) <= series.keys(): + print(f"{station} : ignorée, pas de mesures du disque ({', '.join(METRICS)})") + continue + path = ROOT / "out" / f"{station}_storage.html" + figure(station, series, ss.run(series), du.run(series)).write_html( + path, include_plotlyjs="cdn", post_script=AUTOSCALE_Y_JS, config={"scrollZoom": True}) + print(path) + written.append(path) + return written + + +if __name__ == "__main__": + for p in main(sys.argv[1:] or [str(ROOT / "data" / "WEISSHORN")]): + open_html(p) diff --git a/src/storage/day_color.py b/src/storage/day_color.py new file mode 100644 index 0000000..50f6e59 --- /dev/null +++ b/src/storage/day_color.py @@ -0,0 +1,49 @@ +"""Couleur du jour Storage : matrice état (DAILY_STORAGE_STATE) × horizon (DAYS_UNTIL_STORAGE_FULL) -> vert / orange / rouge (D-035). + +Documentation : docs/storage/matrice-etat-horizon.drawio, docs/decisions.md (D-035) +Bibliothèque standard uniquement (cible : système embarqué de la station). +""" +from storage import days_until_full as du, storage_state as ss + +# Jours avant saturation : choix arbitraire de l'utilisateur (2026-10-13), à revoir avec l'expert (délai d'intervention). +ORANGE_DAYS = 60 +RED_DAYS = 14 + +# Matrice tenue par l'utilisateur dans docs/storage/matrice-etat-horizon.drawio : MATRIX[état][horizon]. +# Horizon None : estimation impossible (moins de 4 rythmes dans la fenêtre). État None : gris, l'horizon l'est aussi. +MATRIX = { + "OK": {"BEYOND_60_DAYS": "GREEN", "WITHIN_60_DAYS": "ORANGE", "WITHIN_14_DAYS": "RED", None: None}, + "LOW": {"BEYOND_60_DAYS": "ORANGE", "WITHIN_60_DAYS": "ORANGE", "WITHIN_14_DAYS": "RED", None: "ORANGE"}, + "CRITICAL": {"BEYOND_60_DAYS": "RED", "WITHIN_60_DAYS": "RED", "WITHIN_14_DAYS": "RED", None: "RED"}, +} + +# Une phrase par couleur notifiée, en anglais (D-023) ; Green ne notifie rien (D-025). +HEADLINE = {"RED": "The station is about to run out of storage space.", + "ORANGE": "The station's storage space is running low."} + +RULE = { + "id": "DAY_COLOR", + "verdict": "aucun : anomaly = None ; la couleur est dans facts.color (None = inconnu)", + "orange_days": ORANGE_DAYS, + "red_days": RED_DAYS, + "matrix": MATRIX, + "doc": "docs/storage/matrice-etat-horizon.drawio", +} + + +def horizon(facts): + """Classe de DAYS_UNTIL_STORAGE_FULL ; un disque qui ne se remplit pas est au-delà de 60 jours.""" + if facts["filling"] is None: + return None + days = facts.get("days_until_full", float("inf")) + return "WITHIN_14_DAYS" if days < RED_DAYS else "WITHIN_60_DAYS" if days < ORANGE_DAYS else "BEYOND_60_DAYS" + + +def run(series): + """Couleur du jour, causale comme les deux analyses. Un point par jour UTC.""" + points = [] + for s, d in zip(ss.run(series)["points"], du.run(series)["points"]): # mêmes jours, même ordre (du part de ss) + facts = {**s["facts"], **d["facts"], "horizon": horizon(d["facts"])} + facts["color"] = MATRIX.get(facts["state"], {}).get(facts["horizon"]) + points.append({"t": s["t"], "value": facts["color"], "anomaly": None, "facts": facts}) + return {"analysis": RULE["id"], "rule": RULE, "points": points} diff --git a/src/storage/days_until_full.py b/src/storage/days_until_full.py new file mode 100644 index 0000000..9bf3d8f --- /dev/null +++ b/src/storage/days_until_full.py @@ -0,0 +1,48 @@ +"""DAYS_UNTIL_STORAGE_FULL : jours avant que l'espace libre de /data n'atteigne 0, au rythme des 7 derniers jours. + +Documentation : docs/storage/analyses/days_until_storage_full.md +Bibliothèque standard uniquement (cible : système embarqué de la station). +""" +import statistics +from datetime import datetime, timedelta + +from storage import storage_state as ss + +# Constantes (fiche days_until_storage_full, « Constantes et sources »). +WINDOW_DAYS = 7 # fenêtre de plusieurs jours, multiple de 24 h (principe du projet, CLAUDE.md) +MIN_RATES = 4 # plus de la moitié de la fenêtre : la médiane ne dépend pas d'un seul jour (une purge) + +RULE = { + "id": "DAYS_UNTIL_STORAGE_FULL", + "phase": "estimation seule, sans verdict (anomaly = None)", + "window_days": WINDOW_DAYS, + "min_rates": MIN_RATES, + "doc": "docs/storage/analyses/days_until_storage_full.md", +} + + +def run(series): + """Analyse DAYS_UNTIL_STORAGE_FULL, causale : le jour d n'utilise que les fins de jour jusqu'à d. Un point par jour UTC.""" + free = series["data_storage_free_gb"] + points, rates, prev = [], {}, None # rates : {jour: GiB consommés par jour depuis la fin de jour mesurée précédente} + for p in ss.run(series)["points"]: + d, f = p["t"].date(), p["facts"] + if f["state"] is not None: + t = datetime.fromisoformat(f["measured_at"]) # dernière mesure du jour, valeur non arrondie lue dans la série + if prev: + rates[d] = (free[prev] - free[t]) / ((t - prev) / timedelta(days=1)) + prev = t + window = [r for day, r in rates.items() if d - day < timedelta(days=WINDOW_DAYS)] + facts = {"rates": len(window), "free_gb": f.get("free_gb")} + if f["state"] is None or len(window) < MIN_RATES: + facts["filling"] = None # UNKNOWN : pas de mesure ce jour-là, ou trop peu de jours dans la fenêtre + else: + rate = statistics.median(window) + facts["fill_rate_mib_per_day"] = round(rate * 1024, 2) + facts["filling"] = rate > 0 + if rate > 0: + days = free[t] / rate + facts["days_until_full"] = round(days, 1) + facts["full_date"] = (t + timedelta(days=days)).date().isoformat() + points.append({"t": p["t"], "value": facts.get("days_until_full"), "anomaly": None, "facts": facts}) + return {"analysis": RULE["id"], "rule": RULE, "points": points} diff --git a/src/storage/storage_state.py b/src/storage/storage_state.py new file mode 100644 index 0000000..2921284 --- /dev/null +++ b/src/storage/storage_state.py @@ -0,0 +1,44 @@ +"""DAILY_STORAGE_STATE : espace libre de la partition /data en fin de jour (état seul, sans verdict). + +Documentation : docs/storage/analyses/daily_storage_state.md +Bibliothèque standard uniquement (cible : système embarqué de la station). +""" +import math + +# Constantes (fiche daily_storage_state, « Constantes et sources »). +# Planchers d'espace libre, en % de l'espace utilisable : choix arbitraire de l'utilisateur (2026-10-13), à revoir avec l'expert. +STATES = ["OK", "LOW", "CRITICAL"] # du meilleur au pire +FREE_PERCENT_FLOORS = [20, 10] # plancher de OK, de LOW + +RULE = { + "id": "DAILY_STORAGE_STATE", + "phase": "état seul, sans verdict (anomaly = None)", + "free_percent_floors": FREE_PERCENT_FLOORS, + "doc": "docs/storage/analyses/daily_storage_state.md", +} + + +def day_facts(free_gb, used_gb): + """Dernière mesure du jour (GiB) -> faits et état. Espace utilisable = utilisé + libre, comme le `percent` de psutil : + la réserve de root n'en fait pas partie (docs/storage/domaine/point-de-depart.md).""" + free_percent = 100 * free_gb / (free_gb + used_gb) + state = next((s for s, f in zip(STATES, FREE_PERCENT_FLOORS) if free_percent >= f), STATES[-1]) + return {"state": state, "free_gb": round(free_gb, 4), "free_percent": round(free_percent, 2), + "usable_gb": round(free_gb + used_gb, 4)} + + +def run(series): + """Analyse DAILY_STORAGE_STATE, causale : le jour d n'utilise que ses propres heures. Un point par jour UTC.""" + free, used = series["data_storage_free_gb"], series["data_storage_used_gb"] + last, measured = {}, {} + for t in sorted(free): + last[t.date()] = t + if all(x is not None and math.isfinite(x) for x in (free[t], used.get(t))): # NaN/inf = pas de mesure + measured[t.date()] = t + points = [] + for d in sorted(last): + t = measured.get(d) + facts = day_facts(free[t], used[t]) if t else {"state": None} # UNKNOWN : aucune mesure ce jour-là + facts["measured_at"] = t.isoformat() if t else None + points.append({"t": last[d], "value": facts.get("free_percent"), "anomaly": None, "facts": facts}) + return {"analysis": RULE["id"], "rule": RULE, "points": points}