Fichiers
meteo-collecte/meteo_collecte/infoclimat.py
T
Théo GastineletClaude Opus 5.5 c1e87e91be Secrets lus uniquement dans l'environnement (MC_JETON_INFOCLIMAT, MC_CLE_ROMMA)
Plus aucun fichier de secret : la valeur est lue au moment de l'appel,
jamais copiee, jamais affichee (--config indique seulement definie/absente).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 20:03:53 +02:00

292 lignes
13 KiB
Python

"""Source Infoclimat (open data v2), d'après ~/meteo-direct/direct.py et les règles d'économie du §2.2.
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.
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.
6. Cache serveur : les visiteurs lisent les fichiers publiés, jamais l'API.
Garde-fous : verrou (ordonnanceur), statut vérifié même en HTTP 200, pause 15 min sur toute erreur,
quota commun ~/gws-collecte/quota.json (plafond 4999, jour de Paris) + plafond propre au site (1000/jour,
compté sur le jour de Paris ET sur 24 h glissantes), alerte à 80 % (envoi réel désactivé par défaut).
Le jeton est lu au moment de l'appel, n'est jamais écrit, et est masqué dans tout message.
"""
import datetime as dt
import gzip
import json
import statistics
import urllib.parse
import urllib.request
from .commun import UTC, Pause, ecrire_json, fmt_utc, jour_paris, lire_json, lire_utc, scrub
SOURCE = "infoclimat"
URL_BASE = "https://www.infoclimat.fr/opendata/"
UA = "weather.gastinel.me/0.1 (meteo-collecte)"
DELAI_PUBLICATION_S = 120 # mesuré le 02/10 : ~2 min entre l'instant de mesure et la mise en ligne
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
# 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",
"pression": "pression", "vent_moyen": "vent_moyen", "vent_rafales": "vent_rafales",
"vent_direction": "vent_direction", "pluie_1h": "pluie_1h", "pluie_cumul_0h": "pluie_cumul"}
class ErreurInfoclimat(Exception):
pass
# ---------------------------------------------------------------------------
# Quota
# ---------------------------------------------------------------------------
class Quota:
"""Deux compteurs : le commun (même format que direct.py et le collecteur GWS) et celui du site."""
def __init__(self, cfg, journal, envoyer_alerte=None):
self.cfg = cfg
self.journal = journal
self.fichier_site = cfg.base / "var" / "quota_site.json"
self.envoyer_alerte = envoyer_alerte or (lambda texte: envoyer_ntfy(cfg, texte))
def _commun(self, maintenant):
j = jour_paris(maintenant)
q = lire_json(self.cfg.quota_commun, {})
if q.get("date") != j:
q = {"date": j, "requetes": 0}
return q
def _site(self, maintenant):
j = jour_paris(maintenant)
s = lire_json(self.fichier_site, {})
if s.get("date") != j:
s = {"date": j, "requetes": 0, "alerte_le": s.get("alerte_le"), "horodatages": s.get("horodatages", [])}
limite = maintenant.timestamp() - 86400
s["horodatages"] = [t for t in s.get("horodatages", []) if t > limite]
return s
def etat(self, maintenant):
c, s = self._commun(maintenant), self._site(maintenant)
return {"commun_jour": c["requetes"], "plafond_commun": self.cfg.plafond_commun,
"site_jour": s["requetes"], "site_24h": len(s["horodatages"]), "plafond_site": self.cfg.plafond_site}
def peut(self, n, maintenant):
e = self.etat(maintenant)
return (e["commun_jour"] + n <= self.cfg.plafond_commun and e["site_jour"] + n <= self.cfg.plafond_site
and e["site_24h"] + n <= self.cfg.plafond_site)
def noter(self, n, maintenant):
c = self._commun(maintenant)
c["requetes"] += n
ecrire_json(self.cfg.quota_commun, c, compact=False)
s = self._site(maintenant)
s["requetes"] += n
s["horodatages"].extend([maintenant.timestamp()] * n)
usage = max(s["requetes"], len(s["horodatages"]))
if usage >= self.cfg.seuil_alerte * self.cfg.plafond_site and s.get("alerte_le") != s["date"]:
s["alerte_le"] = s["date"]
texte = "Infoclimat : %d requêtes du site (jour %d, 24 h %d) sur un plafond de %d" % (
usage, s["requetes"], len(s["horodatages"]), self.cfg.plafond_site)
self.journal("ALERTE quota " + texte, maintenant)
try:
self.envoyer_alerte(texte)
except Exception as e: # une alerte ratée ne bloque jamais la collecte
self.journal("alerte non envoyée : %s" % str(e)[:200], maintenant)
ecrire_json(self.fichier_site, s)
return c["requetes"]
def envoyer_ntfy(cfg, texte):
"""Prévu mais inactif : rien n'est envoyé tant que MC_ALERTE_ACTIVE n'est pas à 1 et MC_NTFY_URL vide."""
if not (cfg.alerte_active and cfg.ntfy_url):
return False
req = urllib.request.Request(cfg.ntfy_url, data=texte.encode("utf-8"), headers={"Title": "meteo-collecte"})
urllib.request.urlopen(req, timeout=20).read()
return True
# ---------------------------------------------------------------------------
# Rythme des stations
# ---------------------------------------------------------------------------
def mesurer_rythme(instants):
"""[(dh_utc, recu_utc)...] -> (pas_s, retard_s). Pas = médiane des écarts, arrondi à 5 min, borné."""
dhs = [lire_utc(d) for d, _ in instants]
ecarts = [(b - a).total_seconds() for a, b in zip(dhs, dhs[1:]) if b > a]
if len(ecarts) >= 2:
pas = round(statistics.median(ecarts) / 300) * 300
pas = int(min(max(pas, PAS_MIN_S), PAS_MAX_S))
else:
pas = PAS_DEFAUT_S
retards = [(lire_utc(r) - lire_utc(d)).total_seconds() for d, r in instants]
retard = statistics.median(retards) if retards else None
return pas, retard
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}
return r
def est_due(r, maintenant):
if r["derniere"] is None:
return True
return maintenant >= r["derniere"] + dt.timedelta(seconds=r["pas_s"] + DELAI_PUBLICATION_S)
def est_ponctuelle(r):
return r["retard_s"] is not None and r["retard_s"] <= RETARD_PONCTUEL_S
def type_passage(maintenant):
"""hh:x4..x8 -> passage principal ; hh:x9..x3 -> rattrapage (le minuteur tire à x4 et x9)."""
return "principal" if (maintenant.minute - 4) % 10 < 5 else "rattrapage"
def planifier(etat, rythmes_st, maintenant):
"""Renvoie (type, [stations à demander]). Liste vide = aucun appel."""
genre = type_passage(maintenant)
dues = [sid for sid, r in rythmes_st.items() if est_due(r, maintenant)]
if genre == "principal":
dernier = etat.get("dernier_principal_utc")
if dernier and (maintenant - lire_utc(dernier)).total_seconds() < ECART_MIN_PRINCIPAL_S:
return genre, []
return genre, dues
cibles = [sid for sid in etat.get("manquees", [])
if sid in rythmes_st and sid in dues and est_ponctuelle(rythmes_st[sid])]
return genre, cibles
def fenetre(etat, maintenant, stations, rythmes_st):
"""start=end=aujourd'hui UTC ; veille ajoutée au premier passage après minuit UTC ou pour une station
sans donnée récente."""
auj = maintenant.date()
veille = etat.get("dernier_jour_utc") != str(auj) or any(
rythmes_st[s]["derniere"] is None or rythmes_st[s]["derniere"].date() < auj for s in stations)
return (auj - dt.timedelta(days=1) if veille else auj), auj
def construire_url(stations, debut, fin, jeton):
return (URL_BASE + "?version=2&method=get&format=json&"
+ "&".join("stations[]=" + urllib.parse.quote(s) for s in stations)
+ "&start=%s&end=%s&token=%s" % (debut, fin, urllib.parse.quote(jeton, safe="")))
def telecharger(url):
r = urllib.request.urlopen(urllib.request.Request(
url, headers={"User-Agent": UA, "Accept-Encoding": "gzip"}), timeout=120)
brut = r.read()
if r.headers.get("Content-Encoding") == "gzip":
brut = gzip.decompress(brut)
return brut
def lire_reponse(brut, demandees):
"""-> ({station: [mesures]}, {station: métadonnées}). Lève ErreurInfoclimat si le statut n'est pas OK."""
try:
d = json.loads(brut)
except ValueError:
raise ErreurInfoclimat("réponse non JSON")
if not isinstance(d, dict) or str(d.get("status", "")).upper() != "OK":
err = d.get("errors") if isinstance(d, dict) else d
raise ErreurInfoclimat("statut non OK : %s" % str(err)[:200])
mesures = {}
horaire = d.get("hourly") or {}
for sid in demandees:
lignes = horaire.get(sid) if isinstance(horaire, dict) else None
mesures[sid] = [dict({"dh_utc": x["dh_utc"]}, **{c: x.get(k) for k, c in CORRESPONDANCE.items()})
for x in (lignes or []) if isinstance(x, dict) and "dh_utc" in x]
meta = {}
for m in d.get("stations") or []:
if isinstance(m, dict) and m.get("id") in demandees:
meta[m["id"]] = {"altitude": m.get("elevation"), "lat": m.get("latitude"), "lon": m.get("longitude"),
"licence": (m.get("license") or {}).get("license", ""), "nom_ic": m.get("name")}
return mesures, meta
# ---------------------------------------------------------------------------
# Passage
# ---------------------------------------------------------------------------
def passer(cfg, stockage, journal, maintenant, stations_cfg, fetch=telecharger, quota=None):
"""Un tick Infoclimat. Renvoie un petit résumé (dict) pour etat.json."""
var = cfg.base / "var"
fichier_etat = var / "etat_infoclimat.json"
etat = lire_json(fichier_etat, {})
pause = Pause(var / "pause_infoclimat.txt")
quota = quota or Quota(cfg, journal)
resume = {"source": SOURCE, "action": "rien", "requetes": 0}
if pause.active(maintenant):
resume.update(action="pause", jusqua=fmt_utc(pause.jusqua()))
return resume
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))
genre, cibles = planifier(etat, r, maintenant)
resume["type"] = genre
if not cibles:
return resume
try:
jeton = cfg.secret(cfg.var_jeton_infoclimat)
except LookupError:
journal("jeton Infoclimat illisible, aucun appel", maintenant)
resume["action"] = "sans_jeton"
return resume
journal.masquer(jeton)
nouvelles_total, recues, ok = 0, set(), False
for i in range(0, len(cibles), cfg.lot_max):
lot = cibles[i:i + cfg.lot_max]
cout = len(lot) if cfg.compte_par_station else 1
if not quota.peut(cout, maintenant):
journal("plafond atteint (%s), aucun appel" % quota.etat(maintenant), maintenant)
resume["action"] = "plafond"
break
debut, fin = fenetre(etat, maintenant, lot, r)
n = quota.noter(cout, maintenant)
resume["requetes"] += cout
try:
mesures, meta = lire_reponse(fetch(construire_url(lot, debut, fin, jeton)), lot)
except Exception as e: # toute erreur = arrêt avec pause de 15 min (décision de Théo)
pause.poser(maintenant)
journal("ERREUR Infoclimat (requête %d du jour) : %s ; pause 15 min"
% (n, scrub(str(e), jeton)[:300]), maintenant)
resume["action"] = "erreur"
resume["erreur"] = scrub(str(e), jeton)[:200]
break
for sid in lot:
nv = stockage.ajouter(SOURCE, sid, mesures.get(sid, []), maintenant)
if nv:
recues.add(sid)
nouvelles_total += nv
if sid in meta:
m = meta[sid]
stockage.maj_station(SOURCE, sid, lat=m["lat"], lon=m["lon"], altitude=m["altitude"],
licence=m["licence"])
ok = True
resume["action"] = "appel"
if ok:
etat["dernier_jour_utc"] = str(maintenant.date())
etat["dernier_succes_utc"] = fmt_utc(maintenant)
if genre == "principal":
etat["dernier_principal_utc"] = fmt_utc(maintenant)
etat["manquees"] = [s for s in cibles if s not in recues]
else:
etat["manquees"] = [s for s in etat.get("manquees", []) if s not in recues]
ecrire_json(fichier_etat, etat, compact=False)
journal("ok %s : %d station(s) demandée(s), %d avec du neuf, %d mesure(s) nouvelle(s) ; quota %s"
% (genre, len(cibles), len(recues), nouvelles_total, quota.etat(maintenant)), maintenant)
resume.update(demandees=len(cibles), nouvelles=nouvelles_total)
return resume