From b8fd17d0e671cc43b1213fcefc4f3b6f7e768302 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Mon, 19 Oct 2026 18:13:33 +0200 Subject: [PATCH] Module weatherlink : lecture de /current par station, cache, limites propres, source separee --- meteo_collecte/weatherlink.py | 222 ++++++++++++++++++ tests/fixtures/weatherlink_current_iss.json | 8 + tests/fixtures/weatherlink_current_vp2.json | 4 + tests/fixtures/weatherlink_erreur.json | 1 + .../weatherlink_sans_temperature.json | 1 + 5 files changed, 236 insertions(+) create mode 100644 meteo_collecte/weatherlink.py create mode 100644 tests/fixtures/weatherlink_current_iss.json create mode 100644 tests/fixtures/weatherlink_current_vp2.json create mode 100644 tests/fixtures/weatherlink_erreur.json create mode 100644 tests/fixtures/weatherlink_sans_temperature.json diff --git a/meteo_collecte/weatherlink.py b/meteo_collecte/weatherlink.py new file mode 100644 index 0000000..43d2867 --- /dev/null +++ b/meteo_collecte/weatherlink.py @@ -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 diff --git a/tests/fixtures/weatherlink_current_iss.json b/tests/fixtures/weatherlink_current_iss.json new file mode 100644 index 0000000..8b8107f --- /dev/null +++ b/tests/fixtures/weatherlink_current_iss.json @@ -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": []} +]} diff --git a/tests/fixtures/weatherlink_current_vp2.json b/tests/fixtures/weatherlink_current_vp2.json new file mode 100644 index 0000000..a472853 --- /dev/null +++ b/tests/fixtures/weatherlink_current_vp2.json @@ -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}]} +]} diff --git a/tests/fixtures/weatherlink_erreur.json b/tests/fixtures/weatherlink_erreur.json new file mode 100644 index 0000000..167a4ac --- /dev/null +++ b/tests/fixtures/weatherlink_erreur.json @@ -0,0 +1 @@ +{"code": 401, "message": "Unauthorized: api-key FAKEKEY123 is not valid"} diff --git a/tests/fixtures/weatherlink_sans_temperature.json b/tests/fixtures/weatherlink_sans_temperature.json new file mode 100644 index 0000000..1cd66b4 --- /dev/null +++ b/tests/fixtures/weatherlink_sans_temperature.json @@ -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}]}]}