11 fichiers modifiés avec 503 ajouts et 3 suppressions

Aucun fichier ne correspond à votre recherche

+16
Voir le fichier
@@ -49,6 +49,22 @@ Uniquement par variables d'environnement, lues au moment de l'appel, jamais écr
Sans la variable, la source ne fait aucun appel (`sans_jeton` / `sans_cle`). Tout message de journal passe
par `scrub` (masque `token=`, `apikey=` et la valeur, en clair ou encodée).
## WeatherLink v2 (nos stations, opt-in)
Lecture de **nos** stations Davis (Allières, Bruyères, Méaudre, Gêve : à vérifier) par l'API WeatherLink v2,
`weatherlink.py`. Désactivée par défaut. Totalement séparée de ROMMA, Infoclimat et Météo-France : autres clés,
aucun accès à `quota.json`, état propre (`var/etat_weatherlink.json`, `var/pause_weatherlink_<compte>.txt`).
Chaque mesure garde la source `weatherlink` (jamais fusionnée avec Infoclimat/ROMMA, même station physique).
* `MC_WEATHERLINK_ACTIF=1` pour activer ; comptes décrits dans `config/weatherlink.json` (`MC_WEATHERLINK_COMPTES`) :
un compte = une clé API, avec les **noms** de ses deux variables (`MC_WL_ALLIERES_CLE`/`_SECRET`,
`MC_WL_BRUYERES_CLE`/`_SECRET`). Sans les variables d'un compte : aucun appel (`sans_cle`).
* Une requête `GET /current/{station_id}` par station (pas de requête groupée), au plus toutes les 10 min
(`MC_WL_INTERVALLE_S`, minimum 300), 0,5 s entre deux appels, plafond propre `MC_WL_MAX_HEURE` (120/h/compte,
dur 900 ; l'API donne 1000/h et 10/s par clé). Erreur : pause 15 min ; 429 : 1 h ; 401/403 : 6 h ; le compte s'arrête.
* Secret en en-tête `X-Api-Secret`, clé en `api-key=` (masquée dans les journaux). `station_id` null = ignorée.
* À vérifier sur une vraie réponse : noms de champs et unités de `/current` (supposées impériales), code de limite.
## Commandes
```sh
+21
Voir le fichier
@@ -0,0 +1,21 @@
{
"_note": "Comptes WeatherLink v2 (nos stations). Ce fichier ne contient JAMAIS de valeur secrète : seulement les NOMS des variables d'environnement qui portent la clé et le secret. Une clé API par compte. Fonction désactivée par défaut (MC_WEATHERLINK_ACTIF=1 pour l'activer). station_id null = à fournir par Théo : la station est ignorée tant qu'il manque.",
"comptes": {
"allieres": {
"var_cle": "MC_WL_ALLIERES_CLE",
"var_secret": "MC_WL_ALLIERES_SECRET",
"stations": {
"ALLIERES": {"station_id": null, "nom": "Lans-en-Vercors – Les Allières", "altitude": 1449, "a_verifier": "station_id WeatherLink à fournir par Théo"}
}
},
"bruyeres-meaudre": {
"var_cle": "MC_WL_BRUYERES_CLE",
"var_secret": "MC_WL_BRUYERES_SECRET",
"stations": {
"BRUYERES": {"station_id": "41723", "nom": "Lans-en-Vercors – Les Bruyères", "altitude": 990},
"MEAUDRE": {"station_id": "208771", "nom": "Méaudre", "altitude": 976},
"GEVE": {"station_id": "211934", "nom": "Autrans – Gêve nordique", "altitude": 1353, "a_verifier": "même compte/clé que Bruyères et Méaudre ? Box débranchée sur place (journal 29/09)"}
}
}
}
}
+10 -1
Voir le fichier
@@ -40,6 +40,11 @@ class Config:
fiche_heures: int = 48
romma_actif: bool = True
infoclimat_actif: bool = True
# WeatherLink v2 (nos stations) : opt-in, désactivé par défaut. Source entièrement séparée des quotas des autres.
weatherlink_actif: bool = False
weatherlink_comptes: Path = None # JSON des comptes (noms de variables seulement, jamais de valeurs)
wl_intervalle_s: int = 600 # une lecture par station au plus toutes les 10 min (minimum 300)
wl_max_heure: int = 120 # requêtes/heure/compte (plafond dur 900 ; l'API donne 1000/h et 10/s par clé)
direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN)
servi: Path = None # si défini : copie des seuls fichiers réguliers de public/data/ (voir publier.py)
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
@@ -82,6 +87,10 @@ class Config:
lot_max=int(e.get("MC_LOT_MAX", 25)),
romma_actif=oui("MC_ROMMA_ACTIF", True),
infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True),
weatherlink_actif=oui("MC_WEATHERLINK_ACTIF", False),
weatherlink_comptes=chemin("MC_WEATHERLINK_COMPTES", Path(__file__).resolve().parent.parent / "config" / "weatherlink.json"),
wl_intervalle_s=max(300, int(e.get("MC_WL_INTERVALLE_S", 600))),
wl_max_heure=min(900, int(e.get("MC_WL_MAX_HEURE", 120))),
direct_compat=chemin("MC_DIRECT_COMPAT", None),
servi=chemin("MC_SERVI", None),
env=env,
@@ -168,7 +177,7 @@ def ecrire_json(p, d, compact=True):
def scrub(texte, *secrets):
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
texte = re.sub(r"(?i)\b(token|apikey|api-key)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
for s in secrets:
if s:
texte = texte.replace(s, "***")
+13 -2
Voir le fichier
@@ -13,13 +13,13 @@ ni l'autre source ni la publication.
import datetime as dt
import sys
from . import infoclimat, publier, romma
from . import infoclimat, publier, romma, weatherlink
from .commun import UTC, Config, Journal, Verrou, lire_json
from .stockage import Stockage
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
appels=True):
appels=True, fetch_weatherlink=weatherlink.telecharger, dormir_weatherlink=None):
maintenant = maintenant or dt.datetime.now(UTC)
var = cfg.base / "var"
journal = Journal(var / "collecte.log")
@@ -32,6 +32,9 @@ def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_ro
if appels and cfg.romma_actif:
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
if appels and cfg.weatherlink_actif: # opt-in ; quota et état entièrement séparés
resumes["weatherlink"] = _sans_planter(journal, maintenant, "weatherlink", lambda: weatherlink.passer(
cfg, stockage, journal, maintenant, fetch_weatherlink, dormir_weatherlink))
if appels and cfg.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
@@ -67,6 +70,14 @@ def main(argv=None):
print("%-20s définie (valeur masquée)" % nom)
except LookupError:
print("%-20s absente" % nom)
if cfg.weatherlink_actif:
for compte, d in lire_json(cfg.weatherlink_comptes, {}).get("comptes", {}).items():
for nom in (d.get("var_cle"), d.get("var_secret")):
try:
cfg.secret(nom)
print("%-28s définie (valeur masquée) [compte %s]" % (nom, compte))
except LookupError:
print("%-28s absente [compte %s]" % (nom, compte))
return 0
tick(cfg, appels="--publier" not in argv)
return 0
+12
Voir le fichier
@@ -21,6 +21,7 @@ ATTRIBUTIONS = {
"infoclimat": "Données Infoclimat",
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
"interprétation.",
"weatherlink": "Station Gastinel (Davis), données WeatherLink de la station",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
}
@@ -76,6 +77,17 @@ def etat(cfg, maintenant, resumes):
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
"dernier_passage": (resumes.get(src) or {}).get("action"),
}
if cfg.weatherlink_actif:
e = lire_json(cfg.base / "var" / "etat_weatherlink.json", {})
succes = [c.get("dernier_succes_utc") for c in e.get("comptes", {}).values() if c.get("dernier_succes_utc")]
pauses = [Pause(p, 0) for p in sorted((cfg.base / "var").glob("pause_weatherlink_*.txt"))]
actives = [p for p in pauses if p.active(maintenant)]
sources["weatherlink"] = {
"dernier_succes_utc": iso(lire_utc(max(succes))) if succes else None,
"en_pause": bool(actives),
"pause_jusqua_utc": iso(max(p.jusqua() for p in actives)) if actives else None,
"dernier_passage": ((resumes.get("weatherlink") or {}).get("action")),
}
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
+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}]}]}
+195
Voir le fichier
@@ -0,0 +1,195 @@
import json
import tempfile
import unittest
import urllib.error
from pathlib import Path
from meteo_collecte import ordonnanceur, publier, weatherlink
from meteo_collecte.commun import Config, lire_json, scrub
from meteo_collecte.stockage import Stockage
from tests.aide import FauxReseau, config, fixture, t
CLE_A, SEC_A = "CLEALLIERES-FICTIVE", "SECRETALLIERES-FICTIF"
CLE_B, SEC_B = "CLEBRUYERES-FICTIVE", "SECRETBRUYERES-FICTIF"
APPEL = t(12, 0, jour=19) # ts des fixtures = 11:55 UTC le 19/10/2026
COMPTES = {"comptes": {
"allieres": {"var_cle": "MC_WL_ALLIERES_CLE", "var_secret": "MC_WL_ALLIERES_SECRET",
"stations": {"ALL": {"station_id": None, "nom": "Allières"}}},
"bruyeres-meaudre": {"var_cle": "MC_WL_BRUYERES_CLE", "var_secret": "MC_WL_BRUYERES_SECRET",
"stations": {"B": {"station_id": "41723", "nom": "Bruyères", "altitude": 990},
"M": {"station_id": "208771", "nom": "Méaudre"}}}}}
def pas_de_dormir(s):
pass
class Base(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.cfg, self.journal = config(self.tmp.name, weatherlink_actif=True)
self.cfg.weatherlink_comptes = Path(self.tmp.name) / "comptes.json"
self.cfg.weatherlink_comptes.write_text(json.dumps(COMPTES), encoding="utf-8")
self.cfg.env.update({"MC_WL_BRUYERES_CLE": CLE_B, "MC_WL_BRUYERES_SECRET": SEC_B})
self.s = Stockage(Path(self.tmp.name) / "m.sqlite")
def tearDown(self):
self.s.fermer()
self.tmp.cleanup()
def passer(self, fetch, quand=APPEL):
return weatherlink.passer(self.cfg, self.s, self.journal, quand, fetch, pas_de_dormir)
class TestLecture(unittest.TestCase):
def test_conversions_iss(self):
r = weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", APPEL)
m = r["mesure"]
self.assertEqual(r["dh_utc"], "2026-10-19 11:55:00")
self.assertAlmostEqual(m["temperature"], 10.0)
self.assertAlmostEqual(m["point_de_rosee"], 5.0)
self.assertEqual(m["humidite"], 80.0)
self.assertAlmostEqual(m["vent_moyen"], 16.09344)
self.assertAlmostEqual(m["vent_rafales"], 32.18688)
self.assertEqual(m["vent_direction"], 10.0) # 370 -> 10
self.assertAlmostEqual(m["pluie_cumul"], 12.7)
self.assertAlmostEqual(m["pluie_1h"], 2.54)
self.assertAlmostEqual(m["pression"], 1015.917, places=2) # capteur barométrique distinct, même station
self.assertEqual(m["rayonnement"], 300.0)
def test_vantage_pro2_noms_anciens(self):
m = weatherlink.lire_reponse(fixture("weatherlink_current_vp2.json"), "K", "S", APPEL)["mesure"]
self.assertAlmostEqual(m["temperature"], 0.0)
self.assertEqual((m["humidite"], m["vent_direction"]), (90.0, 90.0))
self.assertAlmostEqual(m["vent_moyen"], 8.04672)
self.assertEqual(m["pluie_cumul"], 0.0) # 0 reste 0, pas None
def test_reponses_inutilisables(self):
for corps in (fixture("weatherlink_sans_temperature.json"), b"<html>", b"[]", b'{"a":1}',
fixture("weatherlink_erreur.json")):
with self.assertRaises(weatherlink.ErreurWeatherLink):
weatherlink.lire_reponse(corps, "FAKEKEY123", "S", APPEL)
with self.assertRaises(weatherlink.ErreurWeatherLink) as c:
weatherlink.lire_reponse(fixture("weatherlink_erreur.json"), "FAKEKEY123", "S", APPEL)
self.assertNotIn("FAKEKEY123", str(c.exception))
def test_futur_refuse(self):
with self.assertRaises(weatherlink.ErreurWeatherLink):
weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", t(11, 0, jour=19))
def test_url_cle_seule_secret_en_entete(self):
u = weatherlink.construire_url("41723", "AB/C")
self.assertEqual(u, "https://api.weatherlink.com/v2/current/41723?api-key=AB%2FC")
self.assertNotIn("***", scrub(u)[:10])
self.assertIn("api-key=***", scrub(u))
class TestPassage(Base):
def test_desactive_par_defaut(self):
self.assertFalse(Config.depuis_env({}).weatherlink_actif)
self.cfg.weatherlink_actif = False
res = FauxReseau(fixture("weatherlink_current_iss.json"))
self.assertEqual(self.passer(res)["action"], "desactive")
self.assertEqual(res.urls, [])
def test_source_distincte_et_pas_de_station_sans_id(self):
class Rec:
def __init__(s): s.appels = []
def __call__(s, url, secret):
s.appels.append((url, secret))
return fixture("weatherlink_current_iss.json" if "41723" in url else "weatherlink_current_vp2.json")
rec = Rec()
r = self.passer(rec)
self.assertEqual(r["requetes"], 2)
self.assertEqual(r["comptes"]["allieres"]["action"], "sans_cle") # pas de clé : aucun appel
self.assertEqual({s for _, s in rec.appels}, {SEC_B}) # secret en en-tête, jamais en URL
self.assertTrue(all(SEC_B not in u and "api-key=" + CLE_B in u for u, _ in rec.appels))
self.assertEqual(self.s.compter("weatherlink"), 2)
self.assertEqual(self.s.compter("infoclimat") + self.s.compter("romma"), 0)
self.assertAlmostEqual(self.s.derniere("weatherlink", "41723")["temperature"], 10.0)
st = {x["station_id"]: x for x in self.s.stations()}
self.assertEqual(st["41723"]["source"], "weatherlink")
self.assertIn("bruyeres-meaudre", st["41723"]["extra"])
def test_station_id_manquant_ignoree(self):
self.cfg.env.update({"MC_WL_ALLIERES_CLE": CLE_A, "MC_WL_ALLIERES_SECRET": SEC_A})
res = FauxReseau(fixture("weatherlink_current_iss.json"))
r = self.passer(lambda u, s: res(u))
self.assertEqual(r["comptes"]["allieres"]["ignorees"], ["ALL"])
self.assertEqual(r["comptes"]["allieres"]["requetes"], 0)
def test_cache_dix_minutes(self):
res = FauxReseau(fixture("weatherlink_current_iss.json"))
f = lambda u, s: res(u)
self.passer(f)
self.assertEqual(len(res.urls), 2)
self.assertEqual(self.passer(f, t(12, 5, jour=19))["requetes"], 0) # moins de 10 min : cache
self.assertEqual(len(res.urls), 2)
self.passer(f, t(12, 11, jour=19))
self.assertEqual(len(res.urls), 4)
def test_plafond_horaire_propre(self):
self.cfg.wl_max_heure = 1
res = FauxReseau(fixture("weatherlink_current_iss.json"))
r = self.passer(lambda u, s: res(u))
self.assertEqual(len(res.urls), 1)
self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "plafond_heure")
def test_erreur_http_pause_et_secrets_masques(self):
def f(url, secret):
raise urllib.error.HTTPError(url, 429, "Too Many Requests " + SEC_B, {}, None)
r = self.passer(f)
self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "erreur")
self.assertEqual(r["requetes"], 1) # le compte s'arrête net
texte = (self.cfg.base / "var" / "journal.log").read_text(encoding="utf-8")
for secret in (CLE_B, SEC_B):
self.assertNotIn(secret, texte)
self.assertNotIn(secret, json.dumps(r))
res = FauxReseau(fixture("weatherlink_current_iss.json"))
r2 = self.passer(lambda u, s: res(u), t(12, 30, jour=19)) # 429 : pause 1 h
self.assertEqual(r2["comptes"]["bruyeres-meaudre"]["action"], "pause")
self.assertEqual(res.urls, [])
self.assertEqual(self.passer(lambda u, s: res(u), t(13, 1, jour=19))["requetes"], 2)
def test_ne_touche_pas_le_quota_infoclimat(self):
res = FauxReseau(fixture("weatherlink_current_iss.json"))
self.passer(lambda u, s: res(u))
self.assertFalse(self.cfg.quota_commun.exists())
self.assertFalse((self.cfg.base / "var" / "etat_romma.json").exists())
class TestIntegration(Base):
def test_tick_et_publication(self):
self.cfg.env.update({"MC_ROMMA_ACTIF": "0"})
self.cfg.romma_actif = self.cfg.infoclimat_actif = False
res = FauxReseau(fixture("weatherlink_current_iss.json"))
ordonnanceur.tick(self.cfg, APPEL, fetch_weatherlink=lambda u, s: res(u), dormir_weatherlink=pas_de_dormir)
data = self.cfg.public / "data"
idx = lire_json(data / "stations.json", {})
par = {x["id"]: x for x in idx["stations"]}
self.assertEqual(set(par), {"weatherlink-41723", "weatherlink-208771"})
self.assertEqual(par["weatherlink-41723"]["source"], "weatherlink")
self.assertIn("Station Gastinel", par["weatherlink-41723"]["attribution"])
self.assertIn("weatherlink", lire_json(data / "etat.json", {})["sources"])
for p in data.rglob("*.json"):
texte = p.read_text(encoding="utf-8")
for secret in (CLE_B, SEC_B, "api-key"):
self.assertNotIn(secret, texte)
def test_tick_desactive_ne_publie_pas_la_source(self):
self.cfg.weatherlink_actif = False
self.cfg.romma_actif = self.cfg.infoclimat_actif = False
ordonnanceur.tick(self.cfg, APPEL)
self.assertNotIn("weatherlink", lire_json(self.cfg.public / "data" / "etat.json", {})["sources"])
def test_fichier_de_comptes_du_depot_sans_valeur_secrete(self):
brut = (Path(__file__).resolve().parent.parent / "config" / "weatherlink.json").read_text(encoding="utf-8")
comptes = json.loads(brut)["comptes"]
for c in comptes.values():
self.assertTrue(c["var_cle"].startswith("MC_WL_") and c["var_secret"].startswith("MC_WL_"))
self.assertEqual(len({c["var_cle"] for c in comptes.values()}), len(comptes)) # une clé par compte
if __name__ == "__main__":
unittest.main()