Comparer les révisions
4
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
de74617447 | |||
|
|
fb235a2c85 | |||
|
|
b8fd17d0e6 | |||
|
|
feb78ba2ab | |||
Aucun fichier ne correspond à votre recherche
@@ -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
|
||||
|
||||
@@ -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)"}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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,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
|
||||
|
||||
@@ -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}
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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": []}
|
||||
]}
|
||||
@@ -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}]}
|
||||
]}
|
||||
@@ -0,0 +1 @@
|
||||
{"code": 401, "message": "Unauthorized: api-key FAKEKEY123 is not valid"}
|
||||
@@ -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}]}]}
|
||||
@@ -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()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur