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>
292 lignes
13 KiB
Python
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
|