Module weatherlink : lecture de /current par station, cache, limites propres, source separee

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-19 18:13:33 +02:00
1 Parent feb78ba2ab
révision b8fd17d0e6
5 fichiers modifiés
+236

Aucun fichier ne correspond à votre recherche

+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}]}]}