Auteur SHA1 Message Date

2026-10-19

Théo Gastinel de74617447 README : section WeatherLink v2 2026-10-19 18:13:33 +02:00
Théo Gastinel fb235a2c85 WeatherLink : branchement dans le tick et la publication (etat, attribution) + tests avec reponses simulees 2026-10-19 18:13:33 +02:00
Théo Gastinel b8fd17d0e6 Module weatherlink : lecture de /current par station, cache, limites propres, source separee 2026-10-19 18:13:33 +02:00
Théo Gastinel feb78ba2ab WeatherLink v2 : options de configuration (desactive par defaut), fichier des comptes (noms de variables), api-key masquee 2026-10-19 18:13:32 +02:00

2026-10-17

Théo GastineletClaude Haiku 5.5 778825198e Securite deploiement : copie sans liens vers MC_SERVI, script Caddy hors du home, listes en NUL
- publier.copier_vers_servi : copie les seuls fichiers ordinaires de public/data vers MC_SERVI ; lien refuse
  dans la source, lien remplace (jamais suivi) dans la destination ; ecriture temporaire O_EXCL|O_NOFOLLOW puis
  os.replace. Caddy ne sert que /data depuis ce dossier.
- Unite : MC_PUBLIC dans ~/meteo-collecte/public, MC_SERVI=/srv/weather.gastinel.me.
- deployer-vps.sh : ne copie plus le script Caddy dans ~ ; il le depose dans ~/meteo-collecte/deploy et affiche
  son sha256 pour une installation root:root 755 dans /usr/local/sbin. Sauvegardes : noms passes en NUL sur
  stdin, pas de commande construite a partir des noms.
- appliquer-caddy-meteo.sh : refuse si /srv/weather.gastinel.me est un lien.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-17 16:45:09 +02:00
Théo GastineletClaude Haiku 5.5 21f7fca8b6 README : procedure de deploiement (corrige le nom du rapport)
Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-17 15:15:49 +02:00
Théo GastineletClaude Haiku 5.5 fdcca5bccc Deploiement VPS : unites utilisateur, script deployer-vps.sh, Caddy weather.gastinel.me
- deploiement/ : unites reelles (EnvironmentFile=%h/.config/meteo-collecte/env, MC_PUBLIC=/srv/weather.gastinel.me,
  MC_DIRECT_COMPAT a cote de direct.json, pas dessus). Minuteur inchange (hh:x4, hh:x9), non active.
- deploy/deployer-vps.sh : copie sans ecraser var/, sauvegardes .avant-deploiement-1017, env cree vide (600),
  --config et --publier de controle sans appel reseau ; --activer seulement si conditions reunies.
- deploy/appliquer-caddy-meteo.sh : bloc weather.gastinel.me (/data/* lecture seule, CORS), sauvegarde
  Caddyfile.avant-meteo-1017, validate, reload, retour arriere.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-17 15:15:40 +02:00
19 fichiers modifiés avec 1326 ajouts et 745 suppressions

Aucun fichier ne correspond à votre recherche

+97 -75
Voir le fichier
@@ -1,75 +1,97 @@
# meteo-collecte
Collecteur du site météo public (weather.gastinel.me). Python 3, bibliothèque standard seulement
(aucune dépendance à installer ; `pytest` est facultatif pour lancer les tests).
Conception : `Gastinel-Projets/site-meteo-architecture-2026-10-15.md`.
Ce dépôt ne touche ni `weather-collector` ni `weather-db`.
## Ce que fait un tick
Lancé toutes les 5 min (hh:x4 et hh:x9) par le minuteur systemd :
1. **ROMMA** (`romma.py`) : au plus une requête `type=live&global=1` toutes les 10 min, toutes stations d'un coup.
2. **Infoclimat** (`infoclimat.py`) : passage principal à hh:x4 seulement si une station est due (rythme
mesuré dans la base), rattrapage ciblé à hh:x9, requêtes groupées par lots de 25, fenêtre d'un jour.
Plafonds : 1000 requêtes/jour pour le site (jour de Paris **et** 24 h glissantes) et quota commun
`~/gws-collecte/quota.json` (4999). Alerte à 80 % (envoi ntfy désactivé par défaut).
3. **Stockage** (`stockage.py`) : SQLite `var/mesures.sqlite`, une ligne par (source, station, instant UTC),
14 jours glissants. Les sources ne sont jamais mélangées.
4. **Publication** (`publier.py`) : fichiers statiques écrits de façon atomique sous `<public>/data/` :
`stations.json`, `station/<source>-<id>.json` (48 h), `etat.json`.
Toute erreur réseau ou de statut pose une pause de 15 min sur la source concernée ; l'autre source et la
publication continuent. Un verrou empêche deux ticks simultanés.
## Configuration (variables d'environnement)
| Variable | Rôle | Défaut |
|---|---|---|
| `MC_BASE` | dossier d'état (var/, base, journal) | `~/meteo-collecte` |
| `MC_PUBLIC` | racine servie par le serveur web | `$MC_BASE/public` |
| `MC_QUOTA_COMMUN` | compteur commun Infoclimat | `~/gws-collecte/quota.json` |
| `MC_STATIONS` | liste des stations Infoclimat | `config/stations.json` |
| `MC_PLAFOND_SITE` / `MC_PLAFOND_COMMUN` | plafonds Infoclimat | 1000 / 4999 |
| `MC_LOT_MAX` | stations par requête | 25 |
| `MC_COMPTE_PAR_STATION` | compter une requête par station | 0 |
| `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 |
| `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide |
| `MC_DIRECT_COMPAT` | écrire aussi l'ancien `direct.json` | vide |
### Secrets
Uniquement par variables d'environnement, lues au moment de l'appel, jamais écrites ni affichées :
* `MC_JETON_INFOCLIMAT` : jeton Infoclimat (lié à l'IP du VPS) ;
* `MC_CLE_ROMMA` : clé API ROMMA.
Sans la variable, la source ne fait aucun appel (`sans_jeton` / `sans_cle`). Tout message de journal passe
par `scrub` (masque `token=`, `apikey=` et la valeur, en clair ou encodée).
## Commandes
```sh
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente »
```
## Tests (hors ligne)
```sh
python -m pytest -q # ou : python -m unittest discover -s . -p "test_*.py"
python -m pytest -q -s tests/test_hors_ligne.py # affiche les compteurs de requêtes simulés
```
`tests/__init__.py` coupe le réseau (DNS et connexions hors boucle locale lèvent une erreur) : aucun test ne
peut joindre une API. Les réponses viennent de `tests/fixtures/` ou de petits serveurs simulés ; les secrets
sont des valeurs fictives passées dans un environnement en mémoire. `tests/test_hors_ligne.py` simule
plusieurs jours de ticks (fonctionnement normal, plafond, panne longue, sans secrets, purge, heure d'hiver).
## Déploiement
`deploiement/meteo-collecte.service` et `.timer` sont des **exemples non installés** (unité utilisateur).
Points à vérifier avant installation par Théo : voir les commentaires `[À VÉRIFIER]` en tête du service
(emplacement du code, linger, arrêt de `meteo-direct.timer` pour ne pas compter deux fois le quota).
# meteo-collecte
Collecteur du site météo public (weather.gastinel.me). Python 3, bibliothèque standard seulement
(aucune dépendance à installer ; `pytest` est facultatif pour lancer les tests).
Conception : `Gastinel-Projets/site-meteo-architecture-2026-10-15.md`.
Ce dépôt ne touche ni `weather-collector` ni `weather-db`.
## Ce que fait un tick
Lancé toutes les 5 min (hh:x4 et hh:x9) par le minuteur systemd :
1. **ROMMA** (`romma.py`) : au plus une requête `type=live&global=1` toutes les 10 min, toutes stations d'un coup.
2. **Infoclimat** (`infoclimat.py`) : passage principal à hh:x4 seulement si une station est due (rythme
mesuré dans la base), rattrapage ciblé à hh:x9, requêtes groupées par lots de 25, fenêtre d'un jour.
Plafonds : 1000 requêtes/jour pour le site (jour de Paris **et** 24 h glissantes) et quota commun
`~/gws-collecte/quota.json` (4999). Alerte à 80 % (envoi ntfy désactivé par défaut).
3. **Stockage** (`stockage.py`) : SQLite `var/mesures.sqlite`, une ligne par (source, station, instant UTC),
14 jours glissants. Les sources ne sont jamais mélangées.
4. **Publication** (`publier.py`) : fichiers statiques écrits de façon atomique sous `<public>/data/` :
`stations.json`, `station/<source>-<id>.json` (48 h), `etat.json`.
Toute erreur réseau ou de statut pose une pause de 15 min sur la source concernée ; l'autre source et la
publication continuent. Un verrou empêche deux ticks simultanés.
## Configuration (variables d'environnement)
| Variable | Rôle | Défaut |
|---|---|---|
| `MC_BASE` | dossier d'état (var/, base, journal) | `~/meteo-collecte` |
| `MC_PUBLIC` | racine servie par le serveur web | `$MC_BASE/public` |
| `MC_QUOTA_COMMUN` | compteur commun Infoclimat | `~/gws-collecte/quota.json` |
| `MC_STATIONS` | liste des stations Infoclimat | `config/stations.json` |
| `MC_PLAFOND_SITE` / `MC_PLAFOND_COMMUN` | plafonds Infoclimat | 1000 / 4999 |
| `MC_LOT_MAX` | stations par requête | 25 |
| `MC_COMPTE_PAR_STATION` | compter une requête par station | 0 |
| `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 |
| `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide |
| `MC_DIRECT_COMPAT` | écrire aussi l'ancien `direct.json` | vide |
| `MC_SERVI` | après publication, copie des seuls fichiers ordinaires de `public/data/` vers ce dossier (lu par Caddy) ; liens refusés | vide |
### Secrets
Uniquement par variables d'environnement, lues au moment de l'appel, jamais écrites ni affichées :
* `MC_JETON_INFOCLIMAT` : jeton Infoclimat (lié à l'IP du VPS) ;
* `MC_CLE_ROMMA` : clé API ROMMA.
Sans la variable, la source ne fait aucun appel (`sans_jeton` / `sans_cle`). Tout message de journal passe
par `scrub` (masque `token=`, `apikey=` et la valeur, en clair ou encodée).
## WeatherLink v2 (nos stations, opt-in)
Lecture de **nos** stations Davis (Allières, Bruyères, Méaudre, Gêve : à vérifier) par l'API WeatherLink v2,
`weatherlink.py`. Désactivée par défaut. Totalement séparée de ROMMA, Infoclimat et Météo-France : autres clés,
aucun accès à `quota.json`, état propre (`var/etat_weatherlink.json`, `var/pause_weatherlink_<compte>.txt`).
Chaque mesure garde la source `weatherlink` (jamais fusionnée avec Infoclimat/ROMMA, même station physique).
* `MC_WEATHERLINK_ACTIF=1` pour activer ; comptes décrits dans `config/weatherlink.json` (`MC_WEATHERLINK_COMPTES`) :
un compte = une clé API, avec les **noms** de ses deux variables (`MC_WL_ALLIERES_CLE`/`_SECRET`,
`MC_WL_BRUYERES_CLE`/`_SECRET`). Sans les variables d'un compte : aucun appel (`sans_cle`).
* Une requête `GET /current/{station_id}` par station (pas de requête groupée), au plus toutes les 10 min
(`MC_WL_INTERVALLE_S`, minimum 300), 0,5 s entre deux appels, plafond propre `MC_WL_MAX_HEURE` (120/h/compte,
dur 900 ; l'API donne 1000/h et 10/s par clé). Erreur : pause 15 min ; 429 : 1 h ; 401/403 : 6 h ; le compte s'arrête.
* Secret en en-tête `X-Api-Secret`, clé en `api-key=` (masquée dans les journaux). `station_id` null = ignorée.
* À vérifier sur une vraie réponse : noms de champs et unités de `/current` (supposées impériales), code de limite.
## Commandes
```sh
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente »
```
## Tests (hors ligne)
```sh
python -m pytest -q # ou : python -m unittest discover -s . -p "test_*.py"
python -m pytest -q -s tests/test_hors_ligne.py # affiche les compteurs de requêtes simulés
```
`tests/__init__.py` coupe le réseau (DNS et connexions hors boucle locale lèvent une erreur) : aucun test ne
peut joindre une API. Les réponses viennent de `tests/fixtures/` ou de petits serveurs simulés ; les secrets
sont des valeurs fictives passées dans un environnement en mémoire. `tests/test_hors_ligne.py` simule
plusieurs jours de ticks (fonctionnement normal, plafond, panne longue, sans secrets, purge, heure d'hiver).
## Déploiement (VPS, non activé)
`bash deploy/deployer-vps.sh` (depuis le PC ou le VPS) copie le code dans `~/meteo-collecte`, installe les unités
utilisateur `deploiement/meteo-collecte.service` et `.timer` **sans les activer**, crée `~/.config/meteo-collecte/env`
vide (600) et lance un `--config` et un `--publier` de contrôle. `--activer` active le minuteur, seulement si
linger est actif, `/srv/weather.gastinel.me` est accessible en écriture et `meteo-direct.timer` est arrêté.
Les secrets ne sont jamais saisis par script : Théo les met dans le fichier env avec un éditeur.
Caddy (`weather.gastinel.me`, `/data/*` en lecture seule) : `deploy/appliquer-caddy-meteo.sh`, à lancer par Théo avec sudo.
Procédure complète : `NOTES
apport-deploiement-meteo-collecte-20261017.md`.
+21
Voir le fichier
@@ -0,0 +1,21 @@
{
"_note": "Comptes WeatherLink v2 (nos stations). Ce fichier ne contient JAMAIS de valeur secrète : seulement les NOMS des variables d'environnement qui portent la clé et le secret. Une clé API par compte. Fonction désactivée par défaut (MC_WEATHERLINK_ACTIF=1 pour l'activer). station_id null = à fournir par Théo : la station est ignorée tant qu'il manque.",
"comptes": {
"allieres": {
"var_cle": "MC_WL_ALLIERES_CLE",
"var_secret": "MC_WL_ALLIERES_SECRET",
"stations": {
"ALLIERES": {"station_id": null, "nom": "Lans-en-Vercors – Les Allières", "altitude": 1449, "a_verifier": "station_id WeatherLink à fournir par Théo"}
}
},
"bruyeres-meaudre": {
"var_cle": "MC_WL_BRUYERES_CLE",
"var_secret": "MC_WL_BRUYERES_SECRET",
"stations": {
"BRUYERES": {"station_id": "41723", "nom": "Lans-en-Vercors – Les Bruyères", "altitude": 990},
"MEAUDRE": {"station_id": "208771", "nom": "Méaudre", "altitude": 976},
"GEVE": {"station_id": "211934", "nom": "Autrans – Gêve nordique", "altitude": 1353, "a_verifier": "même compte/clé que Bruyères et Méaudre ? Box débranchée sur place (journal 29/09)"}
}
}
}
}
+32 -33
Voir le fichier
@@ -1,33 +1,32 @@
# EXEMPLE — non installé. Unité « utilisateur » proposée pour le VPS (à relire par Théo avant toute installation).
#
# Installation possible (par Théo, PAS faite ici) :
# mkdir -p ~/.config/systemd/user
# cp deploiement/meteo-collecte.service deploiement/meteo-collecte.timer ~/.config/systemd/user/
# systemctl --user daemon-reload && systemctl --user enable --now meteo-collecte.timer
# (pour tourner sans session ouverte : « loginctl enable-linger <utilisateur> », qui peut demander sudo)
# [À VÉRIFIER] : emplacement réel du code sur le VPS, chemin de python3, linger déjà actif ou non,
# arrêt de meteo-direct.timer avant activation (sinon deux collecteurs comptent le même quota).
[Unit]
Description=meteo-collecte : un tick (ROMMA, Infoclimat, publication des fichiers statiques)
After=network-online.target
Wants=network-online.target
[Service]
Type=oneshot
WorkingDirectory=%h/meteo-collecte/code
# Secrets : variables d'environnement seulement (MC_JETON_INFOCLIMAT, MC_CLE_ROMMA), dans un fichier
# créé à la main par Théo, droits 600, hors du dépôt. Format : une ligne NOM=valeur par secret.
# Le « - » rend le fichier facultatif : sans lui, aucun appel n'est fait (la publication continue).
EnvironmentFile=-%h/meteo-collecte/.secrets/env
Environment=MC_BASE=%h/meteo-collecte
Environment=MC_QUOTA_COMMUN=%h/gws-collecte/quota.json
# Alerte ntfy : désactivée tant que Théo ne l'a pas décidé.
Environment=MC_ALERTE_ACTIVE=0
ExecStart=/usr/bin/python3 -m meteo_collecte.ordonnanceur
TimeoutStartSec=4min
Nice=10
# Durcissement léger compatible avec une unité utilisateur
NoNewPrivileges=yes
PrivateTmp=yes
UMask=0022
# Unité UTILISATEUR (systemd --user) pour le VPS. Installée par deploy/deployer-vps.sh (sans activation).
# Un tick par déclenchement du minuteur meteo-collecte.timer (hh:x4 et hh:x9).
#
# Secrets : uniquement dans %h/.config/meteo-collecte/env (droits 600, créé vide par le script ;
# rempli à la main par Théo, nom=valeur, jamais dans ce fichier ni dans le dépôt).
# Sans valeur, aucun appel n'est fait (sans_jeton / sans_cle) et la publication continue.
[Unit]
Description=meteo-collecte : un tick (ROMMA, Infoclimat, publication des fichiers statiques)
After=network-online.target
Wants=network-online.target
[Service]
Type=oneshot
WorkingDirectory=%h/meteo-collecte
EnvironmentFile=%h/.config/meteo-collecte/env
Environment=MC_BASE=%h/meteo-collecte
# Publication dans le dossier du collecteur, puis copie des seuls fichiers ordinaires vers MC_SERVI (lu par Caddy,
# qui ne sert que /data). Aucun lien symbolique n'est copié (publier.copier_vers_servi).
Environment=MC_PUBLIC=%h/meteo-collecte/public
Environment=MC_SERVI=/srv/weather.gastinel.me
Environment=MC_QUOTA_COMMUN=%h/gws-collecte/quota.json
# Ancien format direct.json, écrit à côté (PAS à la place de ~/meteo-direct/direct.json, lu par cornafserver).
Environment=MC_DIRECT_COMPAT=%h/meteo-collecte/direct-compat.json
# Alerte ntfy : désactivée tant que Théo ne l'a pas décidé.
Environment=MC_ALERTE_ACTIVE=0
ExecStart=/usr/bin/python3 -m meteo_collecte.ordonnanceur
TimeoutStartSec=4min
Nice=10
NoNewPrivileges=yes
PrivateTmp=yes
UMask=0022
+1 -1
Voir le fichier
@@ -1,4 +1,4 @@
# EXEMPLE — non installé. Tick toutes les 5 min à hh:x4 et hh:x9 :
# Minuteur utilisateur : tick toutes les 5 min à hh:x4 et hh:x9 (installé par deploy/deployer-vps.sh, NON activé).
# hh:x4 = passage principal Infoclimat (+ ROMMA si 10 min écoulées), hh:x9 = rattrapage ciblé.
[Unit]
+53
Voir le fichier
@@ -0,0 +1,53 @@
#!/bin/bash
# Caddy pour weather.gastinel.me : sert en LECTURE SEULE /data/* depuis /srv/weather.gastinel.me (JSON publiés
# par meteo-collecte), avec CORS pour le site LAN. Tout le reste : 404.
# Ajoute un bloc en fin de /etc/caddy/Caddyfile. Sauvegarde -> validation -> rechargement ; retour arrière si échec.
# Installation (root:root 755, après vérification du sha256 affiché par deployer-vps.sh) :
# sudo install -o root -g root -m 755 appliquer-caddy-meteo.sh /usr/local/sbin/appliquer-caddy-meteo.sh
# Usage : sudo /usr/local/sbin/appliquer-caddy-meteo.sh
set -euo pipefail
[ "$(id -u)" = 0 ] || { echo "A lancer avec sudo"; exit 1; }
CF=/etc/caddy/Caddyfile
BAK="$CF.avant-meteo-1017"
DOSSIER=/srv/weather.gastinel.me
PROPRIO=${SUDO_USER:-debian}
[ -e "$BAK" ] && { echo "Refus : $BAK existe deja (sauvegarde precedente conservee)."; exit 1; }
grep -q "weather.gastinel.me" "$CF" && { echo "Refus : weather.gastinel.me est deja dans le Caddyfile."; exit 1; }
# Dossier servi : copie de fichiers ordinaires faite par le collecteur (MC_SERVI, publier.copier_vers_servi) ;
# il n'est jamais le dossier de publication. Les liens symboliques y sont refusés (ni ce script ni Caddy ne les suivent).
[ -L "$DOSSIER" ] && { echo "Refus : $DOSSIER est un lien symbolique."; exit 1; }
install -d -m 755 -o "$PROPRIO" -g "$PROPRIO" "$DOSSIER"
echo "Dossier : $DOSSIER (proprietaire $PROPRIO)"
cp -a "$CF" "$BAK"
echo "Sauvegarde : $BAK"
cat >> "$CF" <<'CADDY'
# meteo-collecte (weather.gastinel.me) : donnees publiees, lecture seule.
weather.gastinel.me {
import /etc/caddy/securite.caddy
handle /data/* {
header Access-Control-Allow-Origin "*"
header Cache-Control "no-cache"
root * /srv/weather.gastinel.me
file_server
}
handle {
respond "Pas encore en ligne." 404
}
}
CADDY
if caddy validate --config "$CF" --adapter caddyfile && systemctl reload caddy; then
echo "OK : Caddy recharge."
if sudo -u caddy test -r "$DOSSIER" ; then echo "Caddy peut lire $DOSSIER."; else echo "ATTENTION : Caddy ne peut pas lire $DOSSIER."; fi
else
echo "ECHEC : restauration de $BAK"
cp -a "$BAK" "$CF"
systemctl reload caddy || true
exit 1
fi
+115
Voir le fichier
@@ -0,0 +1,115 @@
#!/usr/bin/env bash
# Déploiement de meteo-collecte sur le VPS cornafsuisse (utilisateur debian). Aucun appel API, aucun secret lu ni affiché.
#
# bash deploy/deployer-vps.sh copie le code, installe les unités (NON activées), --config et --publier de contrôle
# bash deploy/deployer-vps.sh --activer active meteo-collecte.timer, seulement si toutes les conditions sont réunies
#
# Lancé depuis le PC (ssh cornafsuisse) ou sur le VPS lui-même (détecté par le nom d'hôte).
# Sans sudo. Tout fichier existant remplacé est sauvegardé en <nom>.avant-deploiement-1017 (jamais écrasé).
# Les noms de fichiers ne sont jamais interpolés dans une commande distante : la liste passe en données NUL.
set -euo pipefail
HOTE_VPS=${HOTE_VPS:-cornafsuisse}
NOM_VPS=ov-edfba0
HORODATAGE=1017
ICI=$(cd "$(dirname "$0")/.." && pwd)
ACTIVER=0
[ "${1:-}" = "--activer" ] && ACTIVER=1
if [ "$(hostname)" = "$NOM_VPS" ]; then
vps() { bash -c "$1"; }
else
vps() { ssh -o BatchMode=yes -o ConnectTimeout=20 "$HOTE_VPS" "$1"; }
fi
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' EXIT
cd "$ICI"
if [ -n "$(git status --porcelain -- meteo_collecte config deploiement deploy)" ]; then
echo "ATTENTION : modifications non commitées ; le VPS recevra l'arbre de travail tel quel."
fi
echo "== 1. Liste des fichiers de code (séparateur NUL)"
find meteo_collecte config -type f ! -path '*/__pycache__/*' ! -name '*.pyc' -print0 | sort -z > "$TMP/liste0"
tr -cd '\0' < "$TMP/liste0" | wc -c
echo "== 2. Sauvegardes de ce qui sera remplacé (.avant-deploiement-$HORODATAGE)"
# Le script distant est fixe (guillemets simples) ; les noms arrivent sur stdin, séparés par NUL.
vps 'C="$HOME/meteo-collecte"; U="$HOME/.config/systemd/user"; H=1017
bak() { if [ -e "$1" ] && [ ! -e "$1.avant-deploiement-'"$HORODATAGE"'" ]; then cp -p -- "$1" "$1.avant-deploiement-'"$HORODATAGE"'"; echo "sauvegarde : $1"; fi; }
while IFS= read -r -d "" f; do bak "$C/$f"; done
bak "$U/meteo-collecte.service"; bak "$U/meteo-collecte.timer"; echo "sauvegardes terminees"' < "$TMP/liste0"
echo "== 3. Copie du code dans ~/meteo-collecte (var/ et public/ ne sont jamais touchés)"
vps 'mkdir -p "$HOME/meteo-collecte"'
tar -C "$ICI" -cf - --exclude='__pycache__' --exclude='*.pyc' meteo_collecte config \
| vps 'tar -C "$HOME/meteo-collecte" -xf -'
echo "== 4. Unités systemd utilisateur (installées, non activées)"
vps 'mkdir -p "$HOME/.config/systemd/user" && cat > "$HOME/.config/systemd/user/meteo-collecte.service"' \
< "$ICI/deploiement/meteo-collecte.service"
vps 'cat > "$HOME/.config/systemd/user/meteo-collecte.timer"' < "$ICI/deploiement/meteo-collecte.timer"
vps 'systemctl --user daemon-reload'
echo "== 5. Fichier de secrets : créé VIDE s'il n'existe pas (contenu jamais affiché)"
vps 'mkdir -p -m 700 "$HOME/.config/meteo-collecte"
E="$HOME/.config/meteo-collecte/env"
if [ ! -e "$E" ]; then (umask 077 && : > "$E"); echo "env cree (vide)"; else echo "env deja present"; fi
chmod 600 "$E"; echo "droits : $(stat -c %a "$E") taille : $(stat -c %s "$E") octets"'
echo "== 6. Script Caddy : copié dans deploy/ (dossier du collecteur, PAS dans ~), à installer en root par Théo"
vps 'mkdir -p "$HOME/meteo-collecte/deploy"'
vps 'cat > "$HOME/meteo-collecte/deploy/appliquer-caddy-meteo.sh"' < "$ICI/deploy/appliquer-caddy-meteo.sh"
SHA=$(sha256sum "$ICI/deploy/appliquer-caddy-meteo.sh" | cut -d' ' -f1)
echo "sha256 attendu : $SHA"
echo "Théo, sur le VPS, vérifier puis installer en root (la commande refuse si le hash diffère) :"
echo " cd ~/meteo-collecte/deploy && echo \"$SHA appliquer-caddy-meteo.sh\" | sha256sum -c - && \\"
echo " sudo install -o root -g root -m 755 appliquer-caddy-meteo.sh /usr/local/sbin/appliquer-caddy-meteo.sh"
echo " sudo /usr/local/sbin/appliquer-caddy-meteo.sh"
echo "== 7. Contrôle --config (noms de variables et « définie / absente » seulement)"
vps 'systemd-run --user --wait --pipe --quiet \
-p WorkingDirectory="$HOME/meteo-collecte" \
-p EnvironmentFile="$HOME/.config/meteo-collecte/env" \
-p Environment=MC_BASE="$HOME/meteo-collecte" \
-p Environment=MC_PUBLIC="$HOME/meteo-collecte/public" \
-p Environment=MC_SERVI= \
-p Environment=MC_DIRECT_COMPAT="$HOME/meteo-collecte/direct-compat.json" \
/usr/bin/python3 -m meteo_collecte.ordonnanceur --config' \
|| echo "ATTENTION : --config non obtenu (systemd-run --user indisponible ?)"
echo "== 8. Contrôle --publier (aucun appel réseau ; écrit dans ~/meteo-collecte/public ; MC_SERVI vide, donc"
echo " rien dans /srv ; MC_DIRECT_COMPAT vide, donc ~/meteo-direct/direct.json n'est jamais touché)"
vps 'cd "$HOME/meteo-collecte" && env -i HOME="$HOME" PATH="$PATH" MC_BASE="$HOME/meteo-collecte" \
MC_PUBLIC="$HOME/meteo-collecte/public" MC_SERVI= MC_DIRECT_COMPAT= /usr/bin/python3 -m meteo_collecte.ordonnanceur --publier \
&& ls -l "$HOME/meteo-collecte/public/data"'
if [ "$ACTIVER" = 0 ]; then
echo
echo "Minuteur NON active. Étapes suivantes : voir rapport-deploiement-meteo-collecte-20261017.md (dossier NOTES)."
echo "Activation, une fois le jeton saisi, le script Caddy installé et linger actif : bash deploy/deployer-vps.sh --activer"
exit 0
fi
echo "== 9. Activation (conditions vérifiées sur le VPS avant)"
vps 'bash -s' <<'DISTANT'
set -eu
ok=1
if [ "$(loginctl show-user "$USER" -p Linger --value 2>/dev/null)" != "yes" ]; then
echo "REFUS : linger desactive. Sans lui le minuteur s'arrete a la fin de la session SSH."
echo " Theo, sur le VPS : sudo loginctl enable-linger debian"; ok=0
fi
if [ ! -d /srv/weather.gastinel.me ] || [ -L /srv/weather.gastinel.me ] || [ ! -w /srv/weather.gastinel.me ]; then
echo "REFUS : /srv/weather.gastinel.me absent, lien, ou non accessible en ecriture."
echo " Theo, sur le VPS : sudo /usr/local/sbin/appliquer-caddy-meteo.sh (voir l'etape 6)"; ok=0
fi
if systemctl is-active --quiet meteo-direct.timer; then
echo "REFUS : meteo-direct.timer est actif (deux collecteurs compteraient le meme quota)."
echo " Theo, sur le VPS : sudo systemctl stop meteo-direct.timer (puis decider de sa desactivation)"; ok=0
fi
[ "$ok" = 1 ] || exit 1
systemctl --user daemon-reload
systemctl --user enable --now meteo-collecte.timer
systemctl --user list-timers meteo-collecte.timer --no-pager
DISTANT
+252 -241
Voir le fichier
@@ -1,241 +1,252 @@
"""Outils communs : configuration, heure de Paris, JSON atomique, journal, verrou, masquage des secrets.
Aucun chemin, nom de serveur ni secret n'est écrit en dur : tout vient de variables d'environnement
(voir `Config.depuis_env`) avec des valeurs par défaut relatives au dossier personnel.
"""
import datetime as dt
import json
import os
import re
import urllib.parse
from dataclasses import dataclass, field
from pathlib import Path
try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows
import fcntl
except ImportError: # pragma: no cover
fcntl = None
UTC = dt.timezone.utc
# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
@dataclass
class Config:
base: Path # état, journal, base SQLite
public: Path # racine servie par Caddy (on écrit dans public/data/)
quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct
stations: Path # liste des stations Infoclimat suivies (JSON)
plafond_commun: int = 4999 # même plafond que le collecteur (décision du 29/09)
plafond_site: int = 1000 # plafond propre au site (décision du 16/10)
seuil_alerte: float = 0.80
alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé
ntfy_url: str = ""
compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4)
lot_max: int = 25
garder_jours: int = 14
fiche_heures: int = 48
romma_actif: bool = True
infoclimat_actif: bool = True
direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN)
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
var_cle_romma: str = "MC_CLE_ROMMA"
env: object = field(default=None, repr=False)
def secret(self, nom_variable):
"""Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide."""
e = os.environ if self.env is None else self.env
v = (e.get(nom_variable) or "").strip()
if not v:
raise LookupError("variable %s absente ou vide" % nom_variable)
return v
@classmethod
def depuis_env(cls, env=None):
e = os.environ if env is None else env
home = Path.home()
base = Path(e.get("MC_BASE") or home / "meteo-collecte")
def chemin(nom, defaut):
return Path(e[nom]) if e.get(nom) else defaut
def oui(nom, defaut):
v = e.get(nom)
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
return cls(
base=base,
public=chemin("MC_PUBLIC", base / "public"),
quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"),
stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"),
plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)),
plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)),
alerte_active=oui("MC_ALERTE_ACTIVE", False),
ntfy_url=e.get("MC_NTFY_URL", ""),
compte_par_station=oui("MC_COMPTE_PAR_STATION", False),
lot_max=int(e.get("MC_LOT_MAX", 25)),
romma_actif=oui("MC_ROMMA_ACTIF", True),
infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True),
direct_compat=chemin("MC_DIRECT_COMPAT", None),
env=env,
)
# ---------------------------------------------------------------------------
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
# ---------------------------------------------------------------------------
def _dernier_dimanche(annee, mois):
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
def decalage_paris(utc):
"""Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST)."""
a = utc.year
debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC)
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC)
return dt.timedelta(hours=2 if debut <= utc < fin else 1)
def vers_paris(utc):
return (utc + decalage_paris(utc)).replace(tzinfo=None)
def paris_vers_utc(local, maintenant=None):
"""Heure locale de Paris (naïve) -> instant UTC.
None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus
récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
"""
possibles = []
for h in (2, 1):
c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC)
if (c + decalage_paris(c)).replace(tzinfo=None) == local:
possibles.append(c)
if not possibles:
return None
if len(possibles) == 1 or maintenant is None:
return possibles[0]
passes = [c for c in possibles if c <= maintenant]
return max(passes) if passes else min(possibles)
def jour_paris(utc):
return str(vers_paris(utc).date())
def fmt_utc(t):
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
def lire_utc(s):
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
def iso(t):
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
# ---------------------------------------------------------------------------
# Fichiers
# ---------------------------------------------------------------------------
def lire_json(p, defaut):
try:
return json.loads(Path(p).read_text(encoding="utf-8"))
except (OSError, ValueError):
return defaut
def ecrire_json(p, d, compact=True):
"""Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
p = Path(p)
p.parent.mkdir(parents=True, exist_ok=True)
tmp = p.with_name(p.name + ".tmp-%d" % os.getpid())
texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None,
indent=None if compact else 1)
tmp.write_text(texte, encoding="utf-8")
os.replace(tmp, p)
def scrub(texte, *secrets):
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
for s in secrets:
if s:
texte = texte.replace(s, "***")
enc = urllib.parse.quote(s, safe="")
if enc != s:
texte = texte.replace(enc, "***")
return texte
class Journal:
"""Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.secrets = []
def masquer(self, *secrets):
self.secrets.extend(s for s in secrets if s)
def __call__(self, msg, maintenant=None):
t = maintenant or dt.datetime.now(UTC)
self.fichier.parent.mkdir(parents=True, exist_ok=True)
with open(self.fichier, "a", encoding="utf-8") as f:
f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n")
class Verrou:
"""Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.f = None
def __enter__(self):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.f = open(self.fichier, "w")
if fcntl is not None:
try:
fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError:
self.f.close()
self.f = None
return False
return True
def __exit__(self, *a):
if self.f:
self.f.close()
class Pause:
"""Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
def __init__(self, fichier, duree_s=15 * 60):
self.fichier = Path(fichier)
self.duree_s = duree_s
def active(self, maintenant):
try:
return float(self.fichier.read_text()) > maintenant.timestamp()
except (OSError, ValueError):
return False
def jusqua(self):
try:
return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC)
except (OSError, ValueError):
return None
def poser(self, maintenant):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.fichier.write_text(str(maintenant.timestamp() + self.duree_s))
"""Outils communs : configuration, heure de Paris, JSON atomique, journal, verrou, masquage des secrets.
Aucun chemin, nom de serveur ni secret n'est écrit en dur : tout vient de variables d'environnement
(voir `Config.depuis_env`) avec des valeurs par défaut relatives au dossier personnel.
"""
import datetime as dt
import json
import os
import re
import urllib.parse
from dataclasses import dataclass, field
from pathlib import Path
try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows
import fcntl
except ImportError: # pragma: no cover
fcntl = None
UTC = dt.timezone.utc
# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
@dataclass
class Config:
base: Path # état, journal, base SQLite
public: Path # racine servie par Caddy (on écrit dans public/data/)
quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct
stations: Path # liste des stations Infoclimat suivies (JSON)
plafond_commun: int = 4999 # même plafond que le collecteur (décision du 29/09)
plafond_site: int = 1000 # plafond propre au site (décision du 16/10)
seuil_alerte: float = 0.80
alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé
ntfy_url: str = ""
compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4)
lot_max: int = 25
garder_jours: int = 14
fiche_heures: int = 48
romma_actif: bool = True
infoclimat_actif: bool = True
# WeatherLink v2 (nos stations) : opt-in, désactivé par défaut. Source entièrement séparée des quotas des autres.
weatherlink_actif: bool = False
weatherlink_comptes: Path = None # JSON des comptes (noms de variables seulement, jamais de valeurs)
wl_intervalle_s: int = 600 # une lecture par station au plus toutes les 10 min (minimum 300)
wl_max_heure: int = 120 # requêtes/heure/compte (plafond dur 900 ; l'API donne 1000/h et 10/s par clé)
direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN)
servi: Path = None # si défini : copie des seuls fichiers réguliers de public/data/ (voir publier.py)
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
var_cle_romma: str = "MC_CLE_ROMMA"
env: object = field(default=None, repr=False)
def secret(self, nom_variable):
"""Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide."""
e = os.environ if self.env is None else self.env
v = (e.get(nom_variable) or "").strip()
if not v:
raise LookupError("variable %s absente ou vide" % nom_variable)
return v
@classmethod
def depuis_env(cls, env=None):
e = os.environ if env is None else env
home = Path.home()
base = Path(e.get("MC_BASE") or home / "meteo-collecte")
def chemin(nom, defaut):
return Path(e[nom]) if e.get(nom) else defaut
def oui(nom, defaut):
v = e.get(nom)
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
return cls(
base=base,
public=chemin("MC_PUBLIC", base / "public"),
quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"),
stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"),
plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)),
plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)),
alerte_active=oui("MC_ALERTE_ACTIVE", False),
ntfy_url=e.get("MC_NTFY_URL", ""),
compte_par_station=oui("MC_COMPTE_PAR_STATION", False),
lot_max=int(e.get("MC_LOT_MAX", 25)),
romma_actif=oui("MC_ROMMA_ACTIF", True),
infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True),
weatherlink_actif=oui("MC_WEATHERLINK_ACTIF", False),
weatherlink_comptes=chemin("MC_WEATHERLINK_COMPTES", Path(__file__).resolve().parent.parent / "config" / "weatherlink.json"),
wl_intervalle_s=max(300, int(e.get("MC_WL_INTERVALLE_S", 600))),
wl_max_heure=min(900, int(e.get("MC_WL_MAX_HEURE", 120))),
direct_compat=chemin("MC_DIRECT_COMPAT", None),
servi=chemin("MC_SERVI", None),
env=env,
)
# ---------------------------------------------------------------------------
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
# ---------------------------------------------------------------------------
def _dernier_dimanche(annee, mois):
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
def decalage_paris(utc):
"""Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST)."""
a = utc.year
debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC)
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC)
return dt.timedelta(hours=2 if debut <= utc < fin else 1)
def vers_paris(utc):
return (utc + decalage_paris(utc)).replace(tzinfo=None)
def paris_vers_utc(local, maintenant=None):
"""Heure locale de Paris (naïve) -> instant UTC.
None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus
récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
"""
possibles = []
for h in (2, 1):
c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC)
if (c + decalage_paris(c)).replace(tzinfo=None) == local:
possibles.append(c)
if not possibles:
return None
if len(possibles) == 1 or maintenant is None:
return possibles[0]
passes = [c for c in possibles if c <= maintenant]
return max(passes) if passes else min(possibles)
def jour_paris(utc):
return str(vers_paris(utc).date())
def fmt_utc(t):
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
def lire_utc(s):
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
def iso(t):
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
# ---------------------------------------------------------------------------
# Fichiers
# ---------------------------------------------------------------------------
def lire_json(p, defaut):
try:
return json.loads(Path(p).read_text(encoding="utf-8"))
except (OSError, ValueError):
return defaut
def ecrire_json(p, d, compact=True):
"""Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
p = Path(p)
p.parent.mkdir(parents=True, exist_ok=True)
tmp = p.with_name(p.name + ".tmp-%d" % os.getpid())
texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None,
indent=None if compact else 1)
tmp.write_text(texte, encoding="utf-8")
os.replace(tmp, p)
def scrub(texte, *secrets):
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
texte = re.sub(r"(?i)\b(token|apikey|api-key)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
for s in secrets:
if s:
texte = texte.replace(s, "***")
enc = urllib.parse.quote(s, safe="")
if enc != s:
texte = texte.replace(enc, "***")
return texte
class Journal:
"""Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.secrets = []
def masquer(self, *secrets):
self.secrets.extend(s for s in secrets if s)
def __call__(self, msg, maintenant=None):
t = maintenant or dt.datetime.now(UTC)
self.fichier.parent.mkdir(parents=True, exist_ok=True)
with open(self.fichier, "a", encoding="utf-8") as f:
f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n")
class Verrou:
"""Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.f = None
def __enter__(self):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.f = open(self.fichier, "w")
if fcntl is not None:
try:
fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError:
self.f.close()
self.f = None
return False
return True
def __exit__(self, *a):
if self.f:
self.f.close()
class Pause:
"""Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
def __init__(self, fichier, duree_s=15 * 60):
self.fichier = Path(fichier)
self.duree_s = duree_s
def active(self, maintenant):
try:
return float(self.fichier.read_text()) > maintenant.timestamp()
except (OSError, ValueError):
return False
def jusqua(self):
try:
return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC)
except (OSError, ValueError):
return None
def poser(self, maintenant):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.fichier.write_text(str(maintenant.timestamp() + self.duree_s))
+3 -29
Voir le fichier
@@ -2,7 +2,6 @@
1. Requêtes groupées : toutes les stations dues dans une seule requête (`stations[]=` répété), lots de 25.
2. Rythme par station *mesuré* dans la base (pas réel 10/15/20 min) ; due à dernière + pas + délai de publication.
2bis. `frequence_min` (dashboard) : due après max(frequence_min, rythme mesuré) ; absent = comportement d'avant.
3. Un passage principal toutes les 10 min (hh:x4), seulement si au moins une station est due.
4. Rattrapage ciblé (hh:x9) : seulement les stations ponctuelles manquées au passage principal.
5. Fenêtre courte : start=end=aujourd'hui UTC ; la veille seulement au premier passage après minuit UTC.
@@ -30,7 +29,6 @@ PAS_DEFAUT_S = 600
PAS_MIN_S, PAS_MAX_S = 600, 3600
RETARD_PONCTUEL_S = 9 * 60 # [À VÉRIFIER] seuil « habituellement ponctuelle » (médiane réception - mesure)
ECART_MIN_PRINCIPAL_S = 8 * 60
FREQ_MIN_MIN, FREQ_MIN_MAX = 5, 1440 # bornes de frequence_min, comme la validation du dashboard meteo-lan
# Champs Infoclimat -> colonnes du stockage (pluie_cumul_0h : cumul depuis 0 h, [À VÉRIFIER] UTC ou Paris)
CORRESPONDANCE = {"temperature": "temperature", "humidite": "humidite", "point_de_rosee": "point_de_rosee",
@@ -129,43 +127,19 @@ def mesurer_rythme(instants):
return pas, retard
def frequences_configurees(stations_cfg, journal=None, maintenant=None):
"""Fréquence réglée dans le dashboard (`frequence_min`, entier 5 à 1440) -> {station: secondes}.
Champ absent : station ignorée ici (comportement inchangé). Valeur invalide : ignorée, une ligne de journal."""
out = {}
for sid, info in stations_cfg.items():
if not isinstance(info, dict) or "frequence_min" not in info:
continue
f = info["frequence_min"]
if isinstance(f, bool) or not isinstance(f, int) or not (FREQ_MIN_MIN <= f <= FREQ_MIN_MAX):
if journal:
journal("frequence_min invalide pour %s (%r : entier %d à %d attendu), ignorée"
% (str(sid)[:40], str(f)[:40], FREQ_MIN_MIN, FREQ_MIN_MAX), maintenant)
continue
out[sid] = f * 60
return out
def rythmes(stockage, ids, frequences=None):
def rythmes(stockage, ids):
r = {}
for sid in ids:
inst = stockage.instants(SOURCE, sid, 30)
pas, retard = mesurer_rythme(inst)
r[sid] = {"derniere": lire_utc(inst[-1][0]) if inst else None, "pas_s": pas, "retard_s": retard}
if frequences and sid in frequences:
r[sid]["frequence_s"] = frequences[sid]
return r
def pas_effectif_s(r):
"""Pas mesuré, relevé à la fréquence réglée si elle est plus lente (jamais plus vite que la station)."""
return max(r["pas_s"], r.get("frequence_s") or 0)
def est_due(r, maintenant):
if r["derniere"] is None:
return True
return maintenant >= r["derniere"] + dt.timedelta(seconds=pas_effectif_s(r) + DELAI_PUBLICATION_S)
return maintenant >= r["derniere"] + dt.timedelta(seconds=r["pas_s"] + DELAI_PUBLICATION_S)
def est_ponctuelle(r):
@@ -256,7 +230,7 @@ def passer(cfg, stockage, journal, maintenant, stations_cfg, fetch=telecharger,
for sid, info in stations_cfg.items():
stockage.maj_station(SOURCE, sid, nom=info.get("nom"), licence=info.get("licence"), lien=info.get("lien"))
r = rythmes(stockage, list(stations_cfg), frequences_configurees(stations_cfg, journal, maintenant))
r = rythmes(stockage, list(stations_cfg))
genre, cibles = planifier(etat, r, maintenant)
resume["type"] = genre
if not cibles:
+87 -74
Voir le fichier
@@ -1,74 +1,87 @@
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
Chaque source décide seule si elle appelle :
* ROMMA : au plus une requête global=1 toutes les 10 min ;
* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9.
Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche
ni l'autre source ni la publication.
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
"""
import datetime as dt
import sys
from . import infoclimat, publier, romma
from .commun import UTC, Config, Journal, Verrou, lire_json
from .stockage import Stockage
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
appels=True):
maintenant = maintenant or dt.datetime.now(UTC)
var = cfg.base / "var"
journal = Journal(var / "collecte.log")
with Verrou(var / ".collecte.lock") as obtenu:
if not obtenu:
return {"action": "verrou"} # un tick précédent tourne encore
stockage = Stockage(var / "mesures.sqlite")
resumes = {}
try:
if appels and cfg.romma_actif:
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
if appels and cfg.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
stockage.purger(maintenant, cfg.garder_jours)
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
finally:
stockage.fermer()
return resumes
def _sans_planter(journal, maintenant, nom, f):
try:
return f()
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
return {"source": nom, "action": "erreur_interne"}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
cfg = Config.depuis_env()
if "--config" in argv:
for k, v in vars(cfg).items():
if k == "env":
continue # l'environnement contient les secrets : jamais affiché
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
try:
cfg.secret(nom)
print("%-20s définie (valeur masquée)" % nom)
except LookupError:
print("%-20s absente" % nom)
return 0
tick(cfg, appels="--publier" not in argv)
return 0
if __name__ == "__main__":
sys.exit(main())
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
Chaque source décide seule si elle appelle :
* ROMMA : au plus une requête global=1 toutes les 10 min ;
* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9.
Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche
ni l'autre source ni la publication.
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
"""
import datetime as dt
import sys
from . import infoclimat, publier, romma, weatherlink
from .commun import UTC, Config, Journal, Verrou, lire_json
from .stockage import Stockage
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
appels=True, fetch_weatherlink=weatherlink.telecharger, dormir_weatherlink=None):
maintenant = maintenant or dt.datetime.now(UTC)
var = cfg.base / "var"
journal = Journal(var / "collecte.log")
with Verrou(var / ".collecte.lock") as obtenu:
if not obtenu:
return {"action": "verrou"} # un tick précédent tourne encore
stockage = Stockage(var / "mesures.sqlite")
resumes = {}
try:
if appels and cfg.romma_actif:
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
if appels and cfg.weatherlink_actif: # opt-in ; quota et état entièrement séparés
resumes["weatherlink"] = _sans_planter(journal, maintenant, "weatherlink", lambda: weatherlink.passer(
cfg, stockage, journal, maintenant, fetch_weatherlink, dormir_weatherlink))
if appels and cfg.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
stockage.purger(maintenant, cfg.garder_jours)
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
if cfg.servi:
resumes["servies"] = publier.copier_vers_servi(cfg.public, cfg.servi)
finally:
stockage.fermer()
return resumes
def _sans_planter(journal, maintenant, nom, f):
try:
return f()
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
return {"source": nom, "action": "erreur_interne"}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
cfg = Config.depuis_env()
if "--config" in argv:
for k, v in vars(cfg).items():
if k == "env":
continue # l'environnement contient les secrets : jamais affiché
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
try:
cfg.secret(nom)
print("%-20s définie (valeur masquée)" % nom)
except LookupError:
print("%-20s absente" % nom)
if cfg.weatherlink_actif:
for compte, d in lire_json(cfg.weatherlink_comptes, {}).get("comptes", {}).items():
for nom in (d.get("var_cle"), d.get("var_secret")):
try:
cfg.secret(nom)
print("%-28s définie (valeur masquée) [compte %s]" % (nom, compte))
except LookupError:
print("%-28s absente [compte %s]" % (nom, compte))
return 0
tick(cfg, appels="--publier" not in argv)
return 0
if __name__ == "__main__":
sys.exit(main())
+152 -96
Voir le fichier
@@ -1,96 +1,152 @@
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
* data/stations.json : index de toutes les stations avec leur dernière mesure ;
* data/station/<source>-<id>.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ;
* data/etat.json : heure de mise à jour par source, sources en pause.
Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage
(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers.
Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API.
"""
import datetime as dt
import re
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
from .stockage import CHAMPS
ATTRIBUTIONS = {
"infoclimat": "Données Infoclimat",
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
"interprétation.",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
}
def nom_fichier(source, station_id):
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
def _releve(r):
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
def _fiche(st):
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
def publier(cfg, stockage, maintenant, resumes=None):
data = cfg.public / "data"
index = []
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
for st in stockage.stations():
fiche = _fiche(st)
der = stockage.derniere(st["source"], st["station_id"])
if der:
fiche["derniere"] = _releve(der)
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
else:
fiche["derniere"], fiche["age_min"] = None, None
index.append(fiche)
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
ecrire_json(data / "station" / (fiche["id"] + ".json"),
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
if cfg.direct_compat:
publier_direct_compat(cfg, stockage, maintenant)
return len(index)
def etat(cfg, maintenant, resumes):
from .commun import Pause, lire_json
sources = {}
for src in ("infoclimat", "romma"):
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
succes = e.get("dernier_succes_utc")
sources[src] = {
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
"en_pause": p.active(maintenant),
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
"dernier_passage": (resumes.get(src) or {}).get("action"),
}
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
def publier_direct_compat(cfg, stockage, maintenant):
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
depuis = maintenant - dt.timedelta(hours=48)
stations, meta = {}, {}
for st in stockage.stations():
if st["source"] != "infoclimat":
continue
rel = []
for r in stockage.serie("infoclimat", st["station_id"], depuis):
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
x["pluie_cumul_0h"] = r.get("pluie_cumul")
rel.append(x)
stations[st["station_id"]] = {"nom": st["nom"], "releves": rel}
meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"],
"licence": st["licence"] or ""}
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations})
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
* data/stations.json : index de toutes les stations avec leur dernière mesure ;
* data/station/<source>-<id>.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ;
* data/etat.json : heure de mise à jour par source, sources en pause.
Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage
(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers.
Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API.
"""
import datetime as dt
import os
import re
import stat
from pathlib import Path
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
from .stockage import CHAMPS
ATTRIBUTIONS = {
"infoclimat": "Données Infoclimat",
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
"interprétation.",
"weatherlink": "Station Gastinel (Davis), données WeatherLink de la station",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
}
def nom_fichier(source, station_id):
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
def _releve(r):
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
def _fiche(st):
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
def publier(cfg, stockage, maintenant, resumes=None):
data = cfg.public / "data"
index = []
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
for st in stockage.stations():
fiche = _fiche(st)
der = stockage.derniere(st["source"], st["station_id"])
if der:
fiche["derniere"] = _releve(der)
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
else:
fiche["derniere"], fiche["age_min"] = None, None
index.append(fiche)
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
ecrire_json(data / "station" / (fiche["id"] + ".json"),
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
if cfg.direct_compat:
publier_direct_compat(cfg, stockage, maintenant)
return len(index)
def etat(cfg, maintenant, resumes):
from .commun import Pause, lire_json
sources = {}
for src in ("infoclimat", "romma"):
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
succes = e.get("dernier_succes_utc")
sources[src] = {
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
"en_pause": p.active(maintenant),
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
"dernier_passage": (resumes.get(src) or {}).get("action"),
}
if cfg.weatherlink_actif:
e = lire_json(cfg.base / "var" / "etat_weatherlink.json", {})
succes = [c.get("dernier_succes_utc") for c in e.get("comptes", {}).values() if c.get("dernier_succes_utc")]
pauses = [Pause(p, 0) for p in sorted((cfg.base / "var").glob("pause_weatherlink_*.txt"))]
actives = [p for p in pauses if p.active(maintenant)]
sources["weatherlink"] = {
"dernier_succes_utc": iso(lire_utc(max(succes))) if succes else None,
"en_pause": bool(actives),
"pause_jusqua_utc": iso(max(p.jusqua() for p in actives)) if actives else None,
"dernier_passage": ((resumes.get("weatherlink") or {}).get("action")),
}
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
def publier_direct_compat(cfg, stockage, maintenant):
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
depuis = maintenant - dt.timedelta(hours=48)
stations, meta = {}, {}
for st in stockage.stations():
if st["source"] != "infoclimat":
continue
rel = []
for r in stockage.serie("infoclimat", st["station_id"], depuis):
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
x["pluie_cumul_0h"] = r.get("pluie_cumul")
rel.append(x)
stations[st["station_id"]] = {"nom": st["nom"], "releves": rel}
meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"],
"licence": st["licence"] or ""}
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations})
def copier_vers_servi(src, dst):
"""Copie data/ de `src` vers `dst` (dossier lu par Caddy, lecture seule côté serveur).
Seuls les fichiers ordinaires sont copiés : tout lien symbolique dans la source fait échouer la copie
(ValueError, rien de copié pour ce fichier). Dans la destination, un lien est remplacé, jamais suivi :
écriture dans un fichier temporaire créé avec O_EXCL|O_NOFOLLOW, puis os.replace (atomique).
Renvoie le nombre de fichiers copiés."""
src, dst = Path(src), Path(dst)
racine = src / "data"
dst.mkdir(parents=True, exist_ok=True)
n = 0
for f in sorted(racine.rglob("*")):
st = os.lstat(f)
if stat.S_ISLNK(st.st_mode):
raise ValueError("lien symbolique refusé dans la source : %s" % f.name)
if not stat.S_ISREG(st.st_mode):
continue
rel = f.relative_to(src)
cible_dir = dst
for morceau in rel.parts[:-1]:
cible_dir = cible_dir / morceau
if cible_dir.is_symlink():
raise ValueError("lien symbolique refusé dans la destination : %s" % cible_dir.name)
cible_dir.mkdir(exist_ok=True)
cible = cible_dir / rel.parts[-1]
tmp = cible_dir / (rel.parts[-1] + ".tmp")
if tmp.is_symlink() or tmp.exists():
tmp.unlink() # supprime l'entrée (un lien n'est jamais suivi)
fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o644)
try:
with os.fdopen(fd, "wb") as out, open(f, "rb") as entree:
out.write(entree.read())
except BaseException:
if tmp.exists() or tmp.is_symlink():
tmp.unlink()
raise
os.replace(str(tmp), str(cible)) # remplace aussi un lien existant, sans le suivre
n += 1
return n
+222
Voir le fichier
@@ -0,0 +1,222 @@
"""Source WeatherLink v2 (Davis) : NOS stations (Allières, Bruyères, Méaudre, Gêve ?), lues à part.
Entièrement séparée de ROMMA, Infoclimat et Météo-France : autres clés, autre API, autre compteur. Elle ne
touche jamais `quota.json` (Infoclimat) ni l'état de ROMMA. Opt-in : `MC_WEATHERLINK_ACTIF=1` ET, pour chaque
compte, ses deux variables d'environnement (clé, secret) ; sans elles, aucun appel (`sans_cle`).
Documentation officielle (https://weatherlink.github.io/v2-api/, lue le 19/10/2026) :
* base `https://api.weatherlink.com/v2` ; clé en paramètre `api-key`, secret en en-tête `X-Api-Secret` (jamais en URL) ;
* `GET /current/{station-id}` (entier ou UUID) ; une requête par station (pas de requête groupée) ;
* limites par défaut : 1000 appels/heure et 10 appels/seconde, par clé ;
* réponse : `station_id`, `generated_at`, `sensors[]` ({lsid, sensor_type, data_structure_type, data[{ts, ...}]}).
À VÉRIFIER (non lisible dans la doc récupérée, noms repris de la connaissance de l'API, à confirmer sur une vraie
réponse) : les noms exacts des champs de chaque capteur, leurs unités (supposées impériales : °F, mph, inHg, in),
et le code HTTP au dépassement de limite (429 supposé).
Chaque donnée garde sa source (« weatherlink ») ; elle n'est jamais fusionnée avec celle d'une autre source, même
pour la même station physique (ex. Bruyères publiée aussi par Infoclimat sous 000T0).
"""
import datetime as dt
import json
import urllib.error
import urllib.parse
import urllib.request
from .commun import UTC, Pause, ecrire_json, fmt_utc, lire_json, scrub
SOURCE = "weatherlink"
URL_BASE = "https://api.weatherlink.com/v2"
UA = "weather.gastinel.me/0.1 (meteo-collecte)"
AVANCE_TOLEREE_S = 15 * 60
ECART_APPELS_S = 0.5 # >= 0,5 s entre deux appels : très en dessous de 10/s
PAUSE_ERREUR_S = 15 * 60
PAUSE_LIMITE_S = 60 * 60 # limite de débit atteinte : une heure
PAUSE_REFUS_S = 6 * 3600 # clé refusée (401/403) : inutile d'insister
class ErreurWeatherLink(Exception):
def __init__(self, message, http=None):
super().__init__(message)
self.http = http
# Champs de /current (À VÉRIFIER). Pour chaque champ publié : noms candidats par ordre de préférence, avec leur
# conversion vers nos unités (°C, %, hPa, km/h, degrés, mm, W/m²).
def _f2c(x): return (x - 32.0) * 5.0 / 9.0
def _mph(x): return x * 1.609344
def _inhg(x): return x * 33.8639
def _inch(x): return x * 25.4
def _id(x): return x
CHAMPS_WL = {
"temperature": (("temp", _f2c), ("temp_out", _f2c)),
"humidite": (("hum", _id), ("hum_out", _id)),
"point_de_rosee": (("dew_point", _f2c),),
"pression": (("bar_sea_level", _inhg), ("bar", _inhg)),
"vent_moyen": (("wind_speed_avg_last_10_min", _mph), ("wind_speed_last", _mph), ("wind_speed", _mph)),
"vent_rafales": (("wind_speed_hi_last_10_min", _mph), ("wind_gust_10_min", _mph)),
"vent_direction": (("wind_dir_scalar_avg_last_10_min", _id), ("wind_dir_last", _id), ("wind_dir", _id)),
"pluie_1h": (("rainfall_last_60_min_in", _inch),),
"pluie_cumul": (("rainfall_daily_in", _inch), ("rain_day_in", _inch)),
"rayonnement": (("solar_rad", _id),),
}
def construire_url(station_id, cle):
"""Seule la clé (non secrète seule) est en URL ; le secret part en en-tête."""
return "%s/current/%s?api-key=%s" % (URL_BASE, urllib.parse.quote(str(station_id), safe=""),
urllib.parse.quote(cle, safe=""))
def _nombre(v):
if isinstance(v, bool) or v is None:
return None
if isinstance(v, (int, float)):
return float(v)
return None
def lire_reponse(corps, cle, secret, maintenant):
"""-> {dh_utc, mesure, capteurs, avertissements}. Lève ErreurWeatherLink si la réponse est inutilisable."""
if isinstance(corps, bytes):
corps = corps.decode("utf-8", errors="replace")
try:
rep = json.loads(corps.strip().lstrip(""))
except ValueError:
raise ErreurWeatherLink("ce n'est pas du JSON (début : « %s »)" % scrub(corps, cle, secret)[:100])
if not isinstance(rep, dict):
raise ErreurWeatherLink("un objet JSON était attendu")
if rep.get("code") not in (None, 200) and "sensors" not in rep: # corps d'erreur de l'API (forme à vérifier)
raise ErreurWeatherLink("erreur API : %s" % scrub(rep.get("message") or rep.get("code"), cle, secret)[:200])
capteurs = rep.get("sensors")
if not isinstance(capteurs, list):
raise ErreurWeatherLink("pas de liste « sensors » dans la réponse")
avert, brut, ts_champ = [], {}, {}
for cap in capteurs:
data = cap.get("data") if isinstance(cap, dict) else None
if not isinstance(data, list) or not data or not isinstance(data[0], dict):
continue # capteur muet (0 enregistrement : normal)
rec = data[0]
ts = rec.get("ts")
for k, v in rec.items():
n = _nombre(v)
if n is not None and k != "ts" and k not in brut: # 1er capteur qui fournit le champ gagne
brut[k], ts_champ[k] = n, ts
mesure, ts_temp = {}, None
for champ, candidats in CHAMPS_WL.items():
for nom, conv in candidats:
if nom in brut:
mesure[champ] = conv(brut[nom])
if champ == "temperature":
ts_temp = ts_champ[nom]
break
if "vent_direction" in mesure:
mesure["vent_direction"] %= 360
if mesure.get("temperature") is None:
raise ErreurWeatherLink("pas de température dans la réponse (capteur absent ou champ inconnu)")
ts = ts_temp if isinstance(ts_temp, (int, float)) else None
if ts is None:
raise ErreurWeatherLink("horodatage (ts) absent")
dh = dt.datetime.fromtimestamp(int(ts), UTC)
if (dh - maintenant).total_seconds() > AVANCE_TOLEREE_S:
raise ErreurWeatherLink("mesure datée dans le futur, ignorée")
return {"dh_utc": fmt_utc(dh), "mesure": mesure, "champs_bruts": sorted(brut), "avertissements": avert}
def telecharger(url, secret):
req = urllib.request.Request(url, headers={"User-Agent": UA, "X-Api-Secret": secret})
return urllib.request.urlopen(req, timeout=30).read()
def _http_vers_erreur(e, cle, secret):
msg = scrub("HTTP %s" % e.code, cle, secret)
return ErreurWeatherLink(msg, http=e.code)
def _nom_sur(nom):
return "".join(c if c.isalnum() or c in "_-" else "_" for c in nom)
def passer(cfg, stockage, journal, maintenant, fetch=telecharger, dormir=None):
"""Un tick WeatherLink. Résumé par compte. `dormir(s)` injectable (tests)."""
import time
dormir = dormir or time.sleep
resume = {"source": SOURCE, "action": "rien", "requetes": 0, "comptes": {}}
if not cfg.weatherlink_actif:
resume["action"] = "desactive" # opt-in
return resume
config = lire_json(cfg.weatherlink_comptes, {}).get("comptes", {})
var = cfg.base / "var"
fichier_etat = var / "etat_weatherlink.json"
etat = lire_json(fichier_etat, {"comptes": {}})
etat.setdefault("comptes", {})
premier = True
for compte, desc in config.items():
r = resume["comptes"][compte] = {"action": "rien", "requetes": 0, "nouvelles": 0}
pause = Pause(var / ("pause_weatherlink_%s.txt" % _nom_sur(compte)), PAUSE_ERREUR_S)
if pause.active(maintenant):
r.update(action="pause", jusqua=fmt_utc(pause.jusqua()))
continue
try:
cle = cfg.secret(desc.get("var_cle", ""))
secret = cfg.secret(desc.get("var_secret", ""))
except LookupError:
r["action"] = "sans_cle" # opt-in : sans clé ni secret, aucun appel
continue
journal.masquer(cle, secret)
e = etat["comptes"].setdefault(compte, {"stations": {}, "appels": []})
# fenêtre glissante d'une heure : plafond propre, bien en dessous de 1000/h
limite = maintenant.timestamp() - 3600
e["appels"] = [x for x in e.get("appels", []) if x > limite]
for cle_st, st in desc.get("stations", {}).items():
sid = st.get("station_id")
if not sid:
r.setdefault("ignorees", []).append(cle_st) # station_id à fournir
continue
sid = str(sid)
dernier = e["stations"].get(sid)
if dernier and maintenant.timestamp() - dernier < cfg.wl_intervalle_s - 30:
continue # cache : déjà lue il y a moins d'un intervalle
if len(e["appels"]) >= cfg.wl_max_heure:
r["action"] = "plafond_heure"
journal("WeatherLink %s : plafond de %d requêtes/heure atteint" % (compte, cfg.wl_max_heure), maintenant)
break
if not premier:
dormir(ECART_APPELS_S)
premier = False
e["appels"].append(maintenant.timestamp())
e["stations"][sid] = maintenant.timestamp()
ecrire_json(fichier_etat, etat, compact=False) # noté AVANT l'appel
r["requetes"] += 1
resume["requetes"] += 1
try:
try:
corps = fetch(construire_url(sid, cle), secret)
except urllib.error.HTTPError as ex:
raise _http_vers_erreur(ex, cle, secret)
lu = lire_reponse(corps, cle, secret, maintenant)
except Exception as ex:
code = getattr(ex, "http", None)
duree = PAUSE_LIMITE_S if code == 429 else PAUSE_REFUS_S if code in (401, 403) else PAUSE_ERREUR_S
Pause(pause.fichier, duree).poser(maintenant)
msg = scrub(str(ex), cle, secret)[:200]
journal("ERREUR WeatherLink %s station %s : %s ; pause %d min" % (compte, sid, msg, duree // 60), maintenant)
r.update(action="erreur", erreur=msg)
break # le compte s'arrête ; les autres comptes continuent
stockage.maj_station(SOURCE, sid, nom=st.get("nom"), lat=st.get("lat"), lon=st.get("lon"),
altitude=st.get("altitude"), licence="Station Gastinel (Davis, via WeatherLink)",
extra=json.dumps({"compte": compte, "a_verifier": st.get("a_verifier")}, ensure_ascii=False))
r["nouvelles"] += stockage.ajouter(SOURCE, sid, [dict(lu["mesure"], dh_utc=lu["dh_utc"])], maintenant)
e["dernier_succes_utc"] = fmt_utc(maintenant)
r["action"] = "appel"
etat["comptes"][compte] = e
ecrire_json(fichier_etat, etat, compact=False)
if any(c["requetes"] for c in resume["comptes"].values()):
resume["action"] = "appel"
journal("ok WeatherLink : %s" % ", ".join("%s %d req/%d nouv." % (k, v["requetes"], v["nouvelles"])
for k, v in resume["comptes"].items() if v["requetes"]), maintenant)
if any(c["action"] == "erreur" for c in resume["comptes"].values()):
resume["action"] = "erreur"
return resume
+8
Voir le fichier
@@ -0,0 +1,8 @@
{"station_id": 41723, "generated_at": 1792410960, "sensors": [
{"lsid": 1001, "sensor_type": 504, "data_structure_type": 15, "data": [{"ts": 1792410900, "battery": 1}]},
{"lsid": 1002, "sensor_type": 45, "data_structure_type": 10, "data": [{"ts": 1792410900, "tx_id": 1,
"temp": 50.0, "hum": 80.0, "dew_point": 41.0, "wind_speed_avg_last_10_min": 10.0, "wind_speed_hi_last_10_min": 20.0,
"wind_dir_scalar_avg_last_10_min": 370, "rainfall_daily_in": 0.5, "rainfall_last_60_min_in": 0.1, "solar_rad": 300}]},
{"lsid": 1003, "sensor_type": 242, "data_structure_type": 12, "data": [{"ts": 1792410840, "bar_sea_level": 30.0, "bar_trend": 0.02}]},
{"lsid": 1004, "sensor_type": 243, "data_structure_type": 12, "data": []}
]}
+4
Voir le fichier
@@ -0,0 +1,4 @@
{"station_id": 208771, "generated_at": 1792410960, "sensors": [
{"lsid": 2001, "sensor_type": 43, "data_structure_type": 2, "data": [{"ts": 1792410900, "temp_out": 32.0, "hum_out": 90,
"wind_speed": 5.0, "wind_dir": 90, "bar": 29.5, "rain_day_in": 0.0}]}
]}
+1
Voir le fichier
@@ -0,0 +1 @@
{"code": 401, "message": "Unauthorized: api-key FAKEKEY123 is not valid"}
+1
Voir le fichier
@@ -0,0 +1 @@
{"station_id": 41723, "generated_at": 1792410960, "sensors": [{"lsid": 1, "sensor_type": 242, "data_structure_type": 12, "data": [{"ts": 1792410900, "bar_sea_level": 30.0}]}]}
+35 -34
Voir le fichier
@@ -1,34 +1,35 @@
"""Contrôles statiques des fichiers systemd d'exemple (pas de systemd sous Windows : rien n'est installé)."""
import datetime as dt
import re
import unittest
from pathlib import Path
from meteo_collecte.infoclimat import type_passage
from tests.aide import t
DOSSIER = Path(__file__).resolve().parent.parent / "deploiement"
class TestUnites(unittest.TestCase):
def test_minuteur_aligne_sur_les_passages(self):
texte = (DOSSIER / "meteo-collecte.timer").read_text(encoding="utf-8")
m = re.search(r"^OnCalendar=\*:(\d\d)/(\d+)$", texte, re.M)
self.assertIsNotNone(m)
depart, pas = int(m.group(1)), int(m.group(2))
minutes = list(range(depart, 60, pas))
self.assertEqual(minutes, [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59])
genres = [type_passage(t(12, 0) + dt.timedelta(minutes=x)) for x in minutes]
self.assertEqual(genres, ["principal", "rattrapage"] * 6)
def test_service_sans_secret_ni_sudo(self):
texte = (DOSSIER / "meteo-collecte.service").read_text(encoding="utf-8")
actif = [l for l in texte.splitlines() if l and not l.startswith("#")]
self.assertTrue(any(l.startswith("ExecStart=") and "meteo_collecte.ordonnanceur" in l for l in actif))
for l in actif:
self.assertNotRegex(l, r"(?i)MC_JETON_INFOCLIMAT=|MC_CLE_ROMMA=|token=|apikey=|sudo")
self.assertIn("EnvironmentFile=-", texte)
if __name__ == "__main__":
unittest.main()
"""Contrôles statiques des fichiers systemd d'exemple (pas de systemd sous Windows : rien n'est installé)."""
import datetime as dt
import re
import unittest
from pathlib import Path
from meteo_collecte.infoclimat import type_passage
from tests.aide import t
DOSSIER = Path(__file__).resolve().parent.parent / "deploiement"
class TestUnites(unittest.TestCase):
def test_minuteur_aligne_sur_les_passages(self):
texte = (DOSSIER / "meteo-collecte.timer").read_text(encoding="utf-8")
m = re.search(r"^OnCalendar=\*:(\d\d)/(\d+)$", texte, re.M)
self.assertIsNotNone(m)
depart, pas = int(m.group(1)), int(m.group(2))
minutes = list(range(depart, 60, pas))
self.assertEqual(minutes, [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59])
genres = [type_passage(t(12, 0) + dt.timedelta(minutes=x)) for x in minutes]
self.assertEqual(genres, ["principal", "rattrapage"] * 6)
def test_service_sans_secret_ni_sudo(self):
texte = (DOSSIER / "meteo-collecte.service").read_text(encoding="utf-8")
actif = [l for l in texte.splitlines() if l and not l.startswith("#")]
self.assertTrue(any(l.startswith("ExecStart=") and "meteo_collecte.ordonnanceur" in l for l in actif))
for l in actif:
self.assertNotRegex(l, r"(?i)MC_JETON_INFOCLIMAT=|MC_CLE_ROMMA=|token=|apikey=|sudo")
self.assertIn("EnvironmentFile=%h/.config/meteo-collecte/env", texte)
self.assertNotIn("EnvironmentFile=-", texte)
if __name__ == "__main__":
unittest.main()
-162
Voir le fichier
@@ -1,162 +0,0 @@
"""frequence_min (réglée dans le dashboard meteo-lan) : due après max(frequence_min, rythme mesuré). Hors ligne."""
import datetime as dt
import json
import tempfile
import unittest
import urllib.parse
from pathlib import Path
from meteo_collecte import infoclimat as ic
from meteo_collecte.commun import UTC
from meteo_collecte.stockage import Stockage
from tests.aide import config, t
def r(derniere, pas_s=600, **kw):
return dict({"derniere": derniere, "pas_s": pas_s, "retard_s": 120}, **kw)
class TestValidation(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.cfg, self.journal = config(self.tmp.name)
def tearDown(self):
self.tmp.cleanup()
def lire_journal(self):
return self.journal.fichier.read_text(encoding="utf-8") if self.journal.fichier.exists() else ""
def test_valeurs_valides(self):
f = ic.frequences_configurees({"a": {"frequence_min": 5}, "b": {"frequence_min": 60},
"c": {"frequence_min": 1440}}, self.journal, t(12, 4))
self.assertEqual(f, {"a": 300, "b": 3600, "c": 86400})
self.assertEqual(self.lire_journal(), "")
def test_champ_absent_ignore_sans_journal(self):
self.assertEqual(ic.frequences_configurees({"a": {"nom": "x"}}, self.journal, t(12, 4)), {})
self.assertEqual(self.lire_journal(), "")
def test_valeurs_invalides_ignorees_avec_une_ligne_chacune(self):
mauvaises = [4, 1441, 0, -10, 30.5, "30", None, True, [30]]
stations = {"s%d" % i: {"frequence_min": v} for i, v in enumerate(mauvaises)}
self.assertEqual(ic.frequences_configurees(stations, self.journal, t(12, 4)), {})
lignes = self.lire_journal().strip().splitlines()
self.assertEqual(len(lignes), len(mauvaises))
self.assertTrue(all("frequence_min invalide" in x for x in lignes))
def test_entree_non_dictionnaire_ne_plante_pas(self):
self.assertEqual(ic.frequences_configurees({"a": "texte", "b": None}, self.journal, t(12, 4)), {})
class TestDue(unittest.TestCase):
def test_sans_champ_comportement_inchange(self):
d = t(12, 0)
self.assertFalse(ic.est_due(r(d), t(12, 11)))
self.assertTrue(ic.est_due(r(d), t(12, 12)))
def test_frequence_plus_lente_que_la_station(self):
d = t(12, 0)
st = r(d, 600, frequence_s=1800)
self.assertFalse(ic.est_due(st, t(12, 31)))
self.assertTrue(ic.est_due(st, t(12, 32))) # 30 min + 2 min de publication
def test_jamais_plus_souvent_que_la_station(self):
d = t(12, 0)
st = r(d, 1800, frequence_s=300) # station lente (30 min), réglage 5 min
self.assertEqual(ic.pas_effectif_s(st), 1800)
self.assertFalse(ic.est_due(st, t(12, 20)))
self.assertTrue(ic.est_due(st, t(12, 32)))
def test_jamais_vue_toujours_due(self):
self.assertTrue(ic.est_due(r(None, 600, frequence_s=3600), t(12, 4)))
def test_planifier_exclut_la_station_non_due(self):
rs = {"lente": r(t(12, 0), 600, frequence_s=3600), "libre": r(t(12, 0), 600)}
genre, cibles = ic.planifier({}, rs, t(12, 14))
self.assertEqual((genre, cibles), ("principal", ["libre"]))
class FauxServeur:
"""Stations qui publient toutes les `pas` minutes avec 2 min de retard ; compte les requêtes et stations."""
def __init__(self, pas=10):
self.pas, self.maintenant = pas, None
self.requetes, self.stations_demandees = 0, 0
def __call__(self, url):
q = urllib.parse.parse_qs(urllib.parse.urlparse(url).query)
ids = q["stations[]"]
self.requetes += 1
self.stations_demandees += len(ids)
debut = dt.datetime.strptime(q["start"][0], "%Y-%m-%d").replace(tzinfo=UTC)
limite = self.maintenant - dt.timedelta(minutes=2)
horaire, m = {}, debut
while m <= limite:
if m.minute % self.pas == 0:
for s in ids:
horaire.setdefault(s, []).append({"dh_utc": m.strftime("%Y-%m-%d %H:%M:%S"), "temperature": "7.0"})
m += dt.timedelta(minutes=1)
return json.dumps({"status": "OK", "errors": [], "stations": [], "hourly": horaire}).encode()
def simuler_24h(frequence_min, nb_stations=3, pas_station=10, debut=None):
"""Tick toutes les 5 min (hh:x4 et hh:x9) pendant 24 h, avec la vraie `passer`. -> (requêtes, stations demandées)."""
debut = debut or dt.datetime(2026, 10, 16, 0, 4, tzinfo=UTC)
stations = {}
for i in range(nb_stations):
stations["S%d" % i] = {"nom": "s", "licence": "CC BY"}
if frequence_min is not None:
stations["S%d" % i]["frequence_min"] = frequence_min
with tempfile.TemporaryDirectory() as tmp:
cfg, journal = config(tmp)
st = Stockage(Path(tmp) / "m.sqlite")
srv = FauxServeur(pas_station)
try:
for k in range(24 * 12):
srv.maintenant = debut + dt.timedelta(minutes=5 * k)
ic.passer(cfg, st, journal, srv.maintenant, stations, fetch=srv)
finally:
st.fermer()
return srv.requetes, srv.stations_demandees
class TestSimulation24h(unittest.TestCase):
resultats = {}
@classmethod
def setUpClass(cls):
for f in (None, 10, 30, 60):
cls.resultats[f] = simuler_24h(f)
base = cls.resultats[None][0]
print("\n[simulation 24 h, 3 stations qui publient toutes les 10 min, 288 ticks de 5 min]")
for f, (req, sta) in cls.resultats.items():
print(" frequence_min=%-5s -> %3d requêtes, %3d demandes de station%s" % (
f if f else "absent", req, sta,
"" if f is None else " (gain %d requêtes, %.0f %%)" % (base - req, 100 * (base - req) / base)))
def test_sans_champ_identique_au_comportement_actuel(self):
self.assertEqual(self.resultats[None][0], 144) # même valeur que test_ordonnanceur (144/24 h)
def test_10_min_egale_la_station(self):
self.assertEqual(self.resultats[10], self.resultats[None])
def test_30_et_60_min_reduisent_les_requetes(self):
self.assertLess(self.resultats[30][0], self.resultats[10][0])
self.assertLess(self.resultats[60][0], self.resultats[30][0])
def test_ordre_de_grandeur(self):
# ~1 requête par période + le premier passage ; marge pour le démarrage et les dérives de 5 min
self.assertTrue(24 * 60 // 30 <= self.resultats[30][0] <= 24 * 60 // 30 + 3)
self.assertTrue(24 * 60 // 60 <= self.resultats[60][0] <= 24 * 60 // 60 + 3)
def test_frequence_5_ne_depasse_pas_le_rythme_de_la_station(self):
self.assertEqual(simuler_24h(5)[0], self.resultats[None][0])
def test_station_lente_30_min_avec_reglage_10(self):
lent = simuler_24h(10, pas_station=30)[0]
self.assertEqual(lent, simuler_24h(None, pas_station=30)[0])
if __name__ == "__main__":
unittest.main()
+47
Voir le fichier
@@ -0,0 +1,47 @@
"""Copie vers le dossier servi : fichiers ordinaires seulement, aucun lien suivi."""
import os
import tempfile
import unittest
from pathlib import Path
from meteo_collecte.publier import copier_vers_servi
class TestCopieServi(unittest.TestCase):
def setUp(self):
self.tmp = Path(tempfile.mkdtemp())
self.src = self.tmp / "public"
self.dst = self.tmp / "servi"
(self.src / "data" / "station").mkdir(parents=True)
(self.src / "data" / "stations.json").write_text('{"ok": 1}', encoding="utf-8")
(self.src / "data" / "station" / "x.json").write_text("{}", encoding="utf-8")
self.secret = self.tmp / "hors_site.txt"
self.secret.write_text("NE DOIT PAS SORTIR", encoding="utf-8")
def test_copie_fichiers_reguliers(self):
self.assertEqual(copier_vers_servi(self.src, self.dst), 2)
self.assertEqual((self.dst / "data" / "stations.json").read_text(encoding="utf-8"), '{"ok": 1}')
self.assertFalse(any(p.name.endswith(".tmp") for p in self.dst.rglob("*")))
def test_lien_dans_la_source_refuse(self):
try:
os.symlink(self.secret, self.src / "data" / "lien.json")
except (OSError, NotImplementedError):
self.skipTest("liens symboliques non disponibles ici")
with self.assertRaises(ValueError):
copier_vers_servi(self.src, self.dst)
self.assertFalse((self.dst / "data" / "lien.json").exists())
def test_lien_dans_la_destination_remplace_sans_suivre(self):
self.dst.joinpath("data").mkdir(parents=True)
try:
os.symlink(self.secret, self.dst / "data" / "stations.json")
except (OSError, NotImplementedError):
self.skipTest("liens symboliques non disponibles ici")
copier_vers_servi(self.src, self.dst)
self.assertFalse((self.dst / "data" / "stations.json").is_symlink())
self.assertEqual(self.secret.read_text(encoding="utf-8"), "NE DOIT PAS SORTIR")
if __name__ == "__main__":
unittest.main()
+195
Voir le fichier
@@ -0,0 +1,195 @@
import json
import tempfile
import unittest
import urllib.error
from pathlib import Path
from meteo_collecte import ordonnanceur, publier, weatherlink
from meteo_collecte.commun import Config, lire_json, scrub
from meteo_collecte.stockage import Stockage
from tests.aide import FauxReseau, config, fixture, t
CLE_A, SEC_A = "CLEALLIERES-FICTIVE", "SECRETALLIERES-FICTIF"
CLE_B, SEC_B = "CLEBRUYERES-FICTIVE", "SECRETBRUYERES-FICTIF"
APPEL = t(12, 0, jour=19) # ts des fixtures = 11:55 UTC le 19/10/2026
COMPTES = {"comptes": {
"allieres": {"var_cle": "MC_WL_ALLIERES_CLE", "var_secret": "MC_WL_ALLIERES_SECRET",
"stations": {"ALL": {"station_id": None, "nom": "Allières"}}},
"bruyeres-meaudre": {"var_cle": "MC_WL_BRUYERES_CLE", "var_secret": "MC_WL_BRUYERES_SECRET",
"stations": {"B": {"station_id": "41723", "nom": "Bruyères", "altitude": 990},
"M": {"station_id": "208771", "nom": "Méaudre"}}}}}
def pas_de_dormir(s):
pass
class Base(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.cfg, self.journal = config(self.tmp.name, weatherlink_actif=True)
self.cfg.weatherlink_comptes = Path(self.tmp.name) / "comptes.json"
self.cfg.weatherlink_comptes.write_text(json.dumps(COMPTES), encoding="utf-8")
self.cfg.env.update({"MC_WL_BRUYERES_CLE": CLE_B, "MC_WL_BRUYERES_SECRET": SEC_B})
self.s = Stockage(Path(self.tmp.name) / "m.sqlite")
def tearDown(self):
self.s.fermer()
self.tmp.cleanup()
def passer(self, fetch, quand=APPEL):
return weatherlink.passer(self.cfg, self.s, self.journal, quand, fetch, pas_de_dormir)
class TestLecture(unittest.TestCase):
def test_conversions_iss(self):
r = weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", APPEL)
m = r["mesure"]
self.assertEqual(r["dh_utc"], "2026-10-19 11:55:00")
self.assertAlmostEqual(m["temperature"], 10.0)
self.assertAlmostEqual(m["point_de_rosee"], 5.0)
self.assertEqual(m["humidite"], 80.0)
self.assertAlmostEqual(m["vent_moyen"], 16.09344)
self.assertAlmostEqual(m["vent_rafales"], 32.18688)
self.assertEqual(m["vent_direction"], 10.0) # 370 -> 10
self.assertAlmostEqual(m["pluie_cumul"], 12.7)
self.assertAlmostEqual(m["pluie_1h"], 2.54)
self.assertAlmostEqual(m["pression"], 1015.917, places=2) # capteur barométrique distinct, même station
self.assertEqual(m["rayonnement"], 300.0)
def test_vantage_pro2_noms_anciens(self):
m = weatherlink.lire_reponse(fixture("weatherlink_current_vp2.json"), "K", "S", APPEL)["mesure"]
self.assertAlmostEqual(m["temperature"], 0.0)
self.assertEqual((m["humidite"], m["vent_direction"]), (90.0, 90.0))
self.assertAlmostEqual(m["vent_moyen"], 8.04672)
self.assertEqual(m["pluie_cumul"], 0.0) # 0 reste 0, pas None
def test_reponses_inutilisables(self):
for corps in (fixture("weatherlink_sans_temperature.json"), b"<html>", b"[]", b'{"a":1}',
fixture("weatherlink_erreur.json")):
with self.assertRaises(weatherlink.ErreurWeatherLink):
weatherlink.lire_reponse(corps, "FAKEKEY123", "S", APPEL)
with self.assertRaises(weatherlink.ErreurWeatherLink) as c:
weatherlink.lire_reponse(fixture("weatherlink_erreur.json"), "FAKEKEY123", "S", APPEL)
self.assertNotIn("FAKEKEY123", str(c.exception))
def test_futur_refuse(self):
with self.assertRaises(weatherlink.ErreurWeatherLink):
weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", t(11, 0, jour=19))
def test_url_cle_seule_secret_en_entete(self):
u = weatherlink.construire_url("41723", "AB/C")
self.assertEqual(u, "https://api.weatherlink.com/v2/current/41723?api-key=AB%2FC")
self.assertNotIn("***", scrub(u)[:10])
self.assertIn("api-key=***", scrub(u))
class TestPassage(Base):
def test_desactive_par_defaut(self):
self.assertFalse(Config.depuis_env({}).weatherlink_actif)
self.cfg.weatherlink_actif = False
res = FauxReseau(fixture("weatherlink_current_iss.json"))
self.assertEqual(self.passer(res)["action"], "desactive")
self.assertEqual(res.urls, [])
def test_source_distincte_et_pas_de_station_sans_id(self):
class Rec:
def __init__(s): s.appels = []
def __call__(s, url, secret):
s.appels.append((url, secret))
return fixture("weatherlink_current_iss.json" if "41723" in url else "weatherlink_current_vp2.json")
rec = Rec()
r = self.passer(rec)
self.assertEqual(r["requetes"], 2)
self.assertEqual(r["comptes"]["allieres"]["action"], "sans_cle") # pas de clé : aucun appel
self.assertEqual({s for _, s in rec.appels}, {SEC_B}) # secret en en-tête, jamais en URL
self.assertTrue(all(SEC_B not in u and "api-key=" + CLE_B in u for u, _ in rec.appels))
self.assertEqual(self.s.compter("weatherlink"), 2)
self.assertEqual(self.s.compter("infoclimat") + self.s.compter("romma"), 0)
self.assertAlmostEqual(self.s.derniere("weatherlink", "41723")["temperature"], 10.0)
st = {x["station_id"]: x for x in self.s.stations()}
self.assertEqual(st["41723"]["source"], "weatherlink")
self.assertIn("bruyeres-meaudre", st["41723"]["extra"])
def test_station_id_manquant_ignoree(self):
self.cfg.env.update({"MC_WL_ALLIERES_CLE": CLE_A, "MC_WL_ALLIERES_SECRET": SEC_A})
res = FauxReseau(fixture("weatherlink_current_iss.json"))
r = self.passer(lambda u, s: res(u))
self.assertEqual(r["comptes"]["allieres"]["ignorees"], ["ALL"])
self.assertEqual(r["comptes"]["allieres"]["requetes"], 0)
def test_cache_dix_minutes(self):
res = FauxReseau(fixture("weatherlink_current_iss.json"))
f = lambda u, s: res(u)
self.passer(f)
self.assertEqual(len(res.urls), 2)
self.assertEqual(self.passer(f, t(12, 5, jour=19))["requetes"], 0) # moins de 10 min : cache
self.assertEqual(len(res.urls), 2)
self.passer(f, t(12, 11, jour=19))
self.assertEqual(len(res.urls), 4)
def test_plafond_horaire_propre(self):
self.cfg.wl_max_heure = 1
res = FauxReseau(fixture("weatherlink_current_iss.json"))
r = self.passer(lambda u, s: res(u))
self.assertEqual(len(res.urls), 1)
self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "plafond_heure")
def test_erreur_http_pause_et_secrets_masques(self):
def f(url, secret):
raise urllib.error.HTTPError(url, 429, "Too Many Requests " + SEC_B, {}, None)
r = self.passer(f)
self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "erreur")
self.assertEqual(r["requetes"], 1) # le compte s'arrête net
texte = (self.cfg.base / "var" / "journal.log").read_text(encoding="utf-8")
for secret in (CLE_B, SEC_B):
self.assertNotIn(secret, texte)
self.assertNotIn(secret, json.dumps(r))
res = FauxReseau(fixture("weatherlink_current_iss.json"))
r2 = self.passer(lambda u, s: res(u), t(12, 30, jour=19)) # 429 : pause 1 h
self.assertEqual(r2["comptes"]["bruyeres-meaudre"]["action"], "pause")
self.assertEqual(res.urls, [])
self.assertEqual(self.passer(lambda u, s: res(u), t(13, 1, jour=19))["requetes"], 2)
def test_ne_touche_pas_le_quota_infoclimat(self):
res = FauxReseau(fixture("weatherlink_current_iss.json"))
self.passer(lambda u, s: res(u))
self.assertFalse(self.cfg.quota_commun.exists())
self.assertFalse((self.cfg.base / "var" / "etat_romma.json").exists())
class TestIntegration(Base):
def test_tick_et_publication(self):
self.cfg.env.update({"MC_ROMMA_ACTIF": "0"})
self.cfg.romma_actif = self.cfg.infoclimat_actif = False
res = FauxReseau(fixture("weatherlink_current_iss.json"))
ordonnanceur.tick(self.cfg, APPEL, fetch_weatherlink=lambda u, s: res(u), dormir_weatherlink=pas_de_dormir)
data = self.cfg.public / "data"
idx = lire_json(data / "stations.json", {})
par = {x["id"]: x for x in idx["stations"]}
self.assertEqual(set(par), {"weatherlink-41723", "weatherlink-208771"})
self.assertEqual(par["weatherlink-41723"]["source"], "weatherlink")
self.assertIn("Station Gastinel", par["weatherlink-41723"]["attribution"])
self.assertIn("weatherlink", lire_json(data / "etat.json", {})["sources"])
for p in data.rglob("*.json"):
texte = p.read_text(encoding="utf-8")
for secret in (CLE_B, SEC_B, "api-key"):
self.assertNotIn(secret, texte)
def test_tick_desactive_ne_publie_pas_la_source(self):
self.cfg.weatherlink_actif = False
self.cfg.romma_actif = self.cfg.infoclimat_actif = False
ordonnanceur.tick(self.cfg, APPEL)
self.assertNotIn("weatherlink", lire_json(self.cfg.public / "data" / "etat.json", {})["sources"])
def test_fichier_de_comptes_du_depot_sans_valeur_secrete(self):
brut = (Path(__file__).resolve().parent.parent / "config" / "weatherlink.json").read_text(encoding="utf-8")
comptes = json.loads(brut)["comptes"]
for c in comptes.values():
self.assertTrue(c["var_cle"].startswith("MC_WL_") and c["var_secret"].startswith("MC_WL_"))
self.assertEqual(len({c["var_cle"] for c in comptes.values()}), len(comptes)) # une clé par compte
if __name__ == "__main__":
unittest.main()