diff --git a/PROPOSITION.md b/PROPOSITION.md new file mode 100644 index 0000000..76db1c3 --- /dev/null +++ b/PROPOSITION.md @@ -0,0 +1,100 @@ +# Proposition — collecteur Infoclimat (cornafsuisse:~/gws-collecte/collecte.py) + +Ce dossier est une copie locale en lecture seule + proposition. **Rien n'a été modifié +sur le VPS.** Aucun appel réel à l'API Infoclimat n'a été fait. Aucun service n'a été +redémarré. Aucun secret n'apparaît ici (le fichier `infoclimat.token` n'a pas été lu). + +- `collecte.py` : copie du script **avec la proposition déjà appliquée** (pour lecture facile). +- Commit git `Original en lecture seule depuis cornafsuisse...` : version actuelle telle + que lue sur le serveur le 2026-09-30 (`sha256`/contenu identique à `~/gws-collecte/collecte.py`). +- `proposition.diff` : diff exact à appliquer (24 insertions, 2 suppressions). + +## Ce que fait le script actuellement + +`collecte.py` tourne comme service systemd (`gws-collecte.service/.timer`, +`gws-maj.service/.timer`) sur `cornafsuisse:~/gws-collecte`. Il boucle sur les stations +Infoclimat et arrête proprement dès que le quota du jour (fichier `quota.json`, remis à +zéro chaque jour Paris) atteint un plafond interne — **ligne 30 : `PLAFOND = 4500`**. +Une réserve de requêtes (`reserve_maj`) est retenue pour la mise à jour de 08:00. + +Gestion des erreurs API (`appeler()` ligne 196, `valider()` ligne 264) : +- **HTTP 429/503** (ligne 231-232) → toujours classé `"limite"` → pause 15 min, arrêt du + run après 4 occurrences consécutives. +- Le corps de la réponse est aussi passé à `analyser_texte()` (ligne 251), qui détecte + du texte libre comme `"too many requests"` → `"limite"`, `"wrong ip"`/`"no account + found"` → `"fatal"` (arrêt d'urgence), `"too many lines"` → réduction de fenêtre. + Ce filtre s'applique **même sur une réponse HTTP 200**, car `valider()` l'appelle avant + de parser le JSON. +- Le format JSON de l'API est déjà connu du code : `{"status": "...", "errors": [...]}` + (regex ligne 275 et 277). Si `status != "OK"` et qu'aucun mot-clé de `analyser_texte` + n'a matché, le code renvoie aujourd'hui `"erreur"` (ligne 278) — traité comme une + erreur de fenêtre ponctuelle (3 essais rapprochés puis abandon de la fenêtre), **pas** + comme une limitation de quota. + +C'est le trou signalé sur le forum Infoclimat : un statut d'erreur avec code HTTP 200 +(ex. quota dépassé annoncé dans `errors` sans les mots-clés déjà reconnus) serait traité +comme une simple erreur de fenêtre et pourrait déclencher des ré-essais au lieu d'une +pause, aggravant un éventuel dépassement. + +**Vérification faite** : `grep -i "erreur" ~/gws-collecte/collecte.log` ne montre à ce +jour que des `HTTP 502` et un `JSON tronque` — **aucun cas réel de `"status non OK"` n'a +encore été observé en production**. La proposition ci-dessous est donc préventive, basée +sur le format JSON déjà géré par le code (`status`/`errors`), pas sur un format deviné. + +## Ce que je propose + +### 1. Plafond 4500 → 4999 +**Fichier : `~/gws-collecte/collecte.py`, ligne 30.** +```python +PLAFOND = 4999 +``` +Avec un commentaire expliquant que la marge de 1 requête est volontaire car le +comportement exact du quota Infoclimat (valeur réelle, heure de reset, fenêtre glissante +ou calendaire) **n'est pas confirmé officiellement** — à surveiller via `quota.json` et +les entrées `"limite"`/429/503 dans `collecte.log` après coup. + +### 2. Détection d'erreur robuste même en HTTP 200 +**Fichier : `~/gws-collecte/collecte.py`, dans `valider()`, lignes 275-278 actuelles.** +Quand `status != "OK"`, on regarde le message déjà extrait du champ `errors` (structure +JSON déjà lue par le code existant, pas une hypothèse nouvelle) et on route vers +`"limite"` (même traitement — pause 15 min — que 429/503) si le message contient un mot +évoquant une limitation (`quota`, `limit`, `trop de requ`, `too many`, `rate`). Sinon, +comportement inchangé (`"erreur"`). + +Limite assumée : la liste de mots-clés est une hypothèse non vérifiée (aucun cas réel +observé à ce jour) — un commentaire dans le code invite à comparer le libellé réel dès +qu'il apparaîtra dans `collecte.log` et à corriger la liste si besoin. + +## Comment appliquer (à faire par Théo, pas par moi) + +Option A — appliquer le diff directement sur le VPS : +```bash +scp "C:\Users\theog\Documents\_CODE\_scratch_collecteur\proposition.diff" cornafsuisse:/tmp/proposition.diff +ssh cornafsuisse +cd ~/gws-collecte +cp collecte.py collecte.py.avant-maj-$(date +%Y%m%d) # sauvegarde avant modif +patch -p1 < /tmp/proposition.diff +python3 -m py_compile collecte.py # verifie la syntaxe +python3 collecte.py --dry-run # verifie que rien n'est casse (aucun appel API) +``` +Puis, seulement si le `--dry-run` est satisfaisant, laisser le prochain run planifié +(`gws-collecte.timer`) appliquer le changement — pas besoin de redémarrer le service +pour une modification de fichier prise en compte au prochain run. + +Option B — copier-coller le fichier complet : remplacer `~/gws-collecte/collecte.py` par +le contenu de `collecte.py` de ce dossier (après avoir vérifié le diff), avec la même +sauvegarde préalable. + +## Limites et incertitudes + +- Le format exact d'un message de quota dépassé en HTTP 200 n'a **jamais été observé** + dans `collecte.log` sur ce serveur — la liste de mots-clés est une hypothèse + raisonnable (basée sur le vocabulaire déjà vu ailleurs dans le code : `"too many + requests"`), pas une certitude. +- La vraie limite quotidienne Infoclimat (5000 ? autre valeur ? fenêtre glissante ?) + n'est pas documentée officiellement à ma connaissance ; 4999 suppose une limite réelle + de 5000 avec reset calendaire Paris — à confirmer par l'usage réel (surveiller + `quota.json` et les 429/503 après le changement). +- Aucun test avec un vrai appel API n'a été fait (interdit dans cette mission) : la + proposition n'a été validée que par relecture + compilation Python locale + (`py_compile`, succès). diff --git a/collecte.py b/collecte.py index bc9e503..c9925aa 100644 --- a/collecte.py +++ b/collecte.py @@ -27,7 +27,13 @@ STOP_F = BASE / "STOP_RAISON.txt" LOCK_F = BASE / ".collecte.lock" PARIS = ZoneInfo("Europe/Paris") -PLAFOND = 4500 +# PROPOSITION 2026-09-30 : 4500 -> 4999. Marge de securite volontaire (1 requete +# sous une limite reelle supposee de 5000/jour) car le comportement exact du +# quota Infoclimat (valeur exacte, heure de reinitialisation, fenetre glissante +# ou compteur calendaire) n'est PAS confirme officiellement. A surveiller apres +# coup via quota.json et les entrees "limite"/HTTP 429/503 de collecte.log ; +# revenir a une valeur plus basse si des 429/503 apparaissent avant la fin de journee. +PLAFOND = 4999 PAUSE = 1.2 # s entre deux debuts de requete (>= 1,1 s) TIMEOUT = 300 UA = "GastinelWeatherStudio/0.4 (collecte historique)" @@ -275,7 +281,23 @@ def valider(part): m = re.search(r'"status"\s*:\s*"([^"]*)"', txt) if not m or m.group(1).upper() != "OK": err = re.search(r'"errors"\s*:\s*\[\s*"([^"]+)"', txt) - return "erreur", "status non OK: " + masquer(err.group(1) if err else txt[:150]) + message = err.group(1) if err else txt[:150] + # PROPOSITION 2026-09-30 : le forum Infoclimat signale des reponses HTTP 200 + # avec un corps JSON status != "OK" pour indiquer un quota depasse (au lieu + # d'un 429/503). On reutilise le champ d'erreur deja lu ci-dessus (structure + # {"status":..., "errors":[...]} deja geree par ce code) et on route vers + # "limite" (meme pause de 15 min que 429/503, cf. appeler()/traiter()) des + # que le message evoque une limitation, plutot que "erreur" (qui ne fait que + # quelques essais rapides avant abandon et pourrait aggraver le depassement). + # HYPOTHESE NON CONFIRMEE : le libelle exact utilise par Infoclimat en cas de + # quota depasse avec HTTP 200 n'a pas ete observe dans collecte.log a ce jour + # (grep -i "erreur" collecte.log ne montre que des HTTP 502 et "JSON tronque"). + # A VERIFIER : des qu'un cas reel apparait, comparer son libelle avec la liste + # de mots-cles ci-dessous et l'completer/corriger si besoin. + bas = message.lower() + if any(mot in bas for mot in ("quota", "limit", "trop de requ", "too many", "rate")): + return "limite", f"status non OK (HTTP 200) : {masquer(message)}" + return "erreur", "status non OK: " + masquer(message) n = tete.count(b'"dh_utc"') reste = tete[-16:] dernier = tete diff --git a/proposition.diff b/proposition.diff new file mode 100644 index 0000000..7c8e9f8 --- /dev/null +++ b/proposition.diff @@ -0,0 +1,44 @@ +diff --git a/collecte.py b/collecte.py +index bc9e503..c9925aa 100644 +--- a/collecte.py ++++ b/collecte.py +@@ -27,7 +27,13 @@ STOP_F = BASE / "STOP_RAISON.txt" + LOCK_F = BASE / ".collecte.lock" + + PARIS = ZoneInfo("Europe/Paris") +-PLAFOND = 4500 ++# PROPOSITION 2026-09-30 : 4500 -> 4999. Marge de securite volontaire (1 requete ++# sous une limite reelle supposee de 5000/jour) car le comportement exact du ++# quota Infoclimat (valeur exacte, heure de reinitialisation, fenetre glissante ++# ou compteur calendaire) n'est PAS confirme officiellement. A surveiller apres ++# coup via quota.json et les entrees "limite"/HTTP 429/503 de collecte.log ; ++# revenir a une valeur plus basse si des 429/503 apparaissent avant la fin de journee. ++PLAFOND = 4999 + PAUSE = 1.2 # s entre deux debuts de requete (>= 1,1 s) + TIMEOUT = 300 + UA = "GastinelWeatherStudio/0.4 (collecte historique)" +@@ -275,7 +281,23 @@ def valider(part): + m = re.search(r'"status"\s*:\s*"([^"]*)"', txt) + if not m or m.group(1).upper() != "OK": + err = re.search(r'"errors"\s*:\s*\[\s*"([^"]+)"', txt) +- return "erreur", "status non OK: " + masquer(err.group(1) if err else txt[:150]) ++ message = err.group(1) if err else txt[:150] ++ # PROPOSITION 2026-09-30 : le forum Infoclimat signale des reponses HTTP 200 ++ # avec un corps JSON status != "OK" pour indiquer un quota depasse (au lieu ++ # d'un 429/503). On reutilise le champ d'erreur deja lu ci-dessus (structure ++ # {"status":..., "errors":[...]} deja geree par ce code) et on route vers ++ # "limite" (meme pause de 15 min que 429/503, cf. appeler()/traiter()) des ++ # que le message evoque une limitation, plutot que "erreur" (qui ne fait que ++ # quelques essais rapides avant abandon et pourrait aggraver le depassement). ++ # HYPOTHESE NON CONFIRMEE : le libelle exact utilise par Infoclimat en cas de ++ # quota depasse avec HTTP 200 n'a pas ete observe dans collecte.log a ce jour ++ # (grep -i "erreur" collecte.log ne montre que des HTTP 502 et "JSON tronque"). ++ # A VERIFIER : des qu'un cas reel apparait, comparer son libelle avec la liste ++ # de mots-cles ci-dessous et l'completer/corriger si besoin. ++ bas = message.lower() ++ if any(mot in bas for mot in ("quota", "limit", "trop de requ", "too many", "rate")): ++ return "limite", f"status non OK (HTTP 200) : {masquer(message)}" ++ return "erreur", "status non OK: " + masquer(message) + n = tete.count(b'"dh_utc"') + reste = tete[-16:] + dernier = tete