14 fichiers modifiés avec 507 ajouts et 194 suppressions

Aucun fichier ne correspond à votre recherche

+16 -1
Voir le fichier
@@ -37,7 +37,6 @@ publication continuent. Un verrou empêche deux ticks simultanés.
| `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 |
| `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide |
| `MC_DIRECT_COMPAT` | écrire aussi l'ancien `direct.json` | vide |
| `MC_JOURNAL_RELAIS` | journal des appels GWS via le relais SSH, ajoutés au quota (vide = désactivé) | `~/gws-relais/journal/appels.log` |
| `MC_SERVI` | après publication, copie des seuls fichiers ordinaires de `public/data/` vers ce dossier (lu par Caddy) ; liens refusés | vide |
### Secrets
@@ -50,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 -9
Voir le fichier
@@ -40,9 +40,13 @@ 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)
journal_relais: Path = None # journal des appels GWS via le relais SSH (None = désactivé)
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
@@ -70,12 +74,6 @@ class Config:
v = e.get(nom)
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
# Variable présente mais vide = désactivé ; absente = défaut.
if "MC_JOURNAL_RELAIS" in e:
journal_relais = Path(e["MC_JOURNAL_RELAIS"]) if (e["MC_JOURNAL_RELAIS"] or "").strip() else None
else:
journal_relais = home / "gws-relais" / "journal" / "appels.log"
return cls(
base=base,
public=chemin("MC_PUBLIC", base / "public"),
@@ -89,9 +87,12 @@ 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),
journal_relais=journal_relais,
env=env,
)
@@ -176,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, "***")
+4 -61
Voir le fichier
@@ -8,7 +8,7 @@
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 + journal du relais GWS (MC_JOURNAL_RELAIS) (plafond 4999, jour de Paris et 24 h) + plafond propre au site (1000/jour,
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.
"""
@@ -44,9 +44,6 @@ class ErreurInfoclimat(Exception):
# Quota
# ---------------------------------------------------------------------------
LECTURE_JOURNAL_MAX = 4_000_000 # octets lus en fin de journal du relais (le journal est en ajout seul)
class Quota:
"""Deux compteurs : le commun (même format que direct.py et le collecteur GWS) et celui du site."""
@@ -54,7 +51,6 @@ class Quota:
self.cfg = cfg
self.journal = journal
self.fichier_site = cfg.base / "var" / "quota_site.json"
self._deja_signales = set()
self.envoyer_alerte = envoyer_alerte or (lambda texte: envoyer_ntfy(cfg, texte))
def _commun(self, maintenant):
@@ -73,68 +69,15 @@ class Quota:
s["horodatages"] = [t for t in s.get("horodatages", []) if t > limite]
return s
def _relais(self, maintenant):
"""(appels du jour de Paris, appels des 24 h glissantes) du journal du relais SSH de GWS.
Lignes `<secondes UTC> <id appareil> <couleur> <nom base64>` ; seules les secondes comptent. Ligne
invalide ou dans le futur (> 60 s) ignorée. Journal désactivé, absent ou illisible : (0, 0) et une ligne
de journal (une seule fois par message et par instance, pour ne pas inonder le journal).
"""
chemin = self.cfg.journal_relais
if not chemin:
return 0, 0
try:
with open(chemin, "rb") as f:
f.seek(0, 2)
taille = f.tell()
f.seek(max(0, taille - LECTURE_JOURNAL_MAX))
brut = f.read(LECTURE_JOURNAL_MAX)
except FileNotFoundError:
self._signaler("journal du relais absent (%s) : 0 appel compté" % chemin, maintenant)
return 0, 0
except Exception as e: # illisible : jamais de plantage
self._signaler("journal du relais illisible (%s) : 0 appel compté" % str(e)[:200], maintenant)
return 0, 0
now = maintenant.timestamp()
jour = jour_paris(maintenant)
n_jour = n_24h = 0
for ligne in brut.decode("utf-8", "replace").splitlines():
champs = ligne.split()
if len(champs) < 2:
continue
try:
ts = int(champs[0])
if ts <= 0 or ts > now + 60:
continue
dans_jour = jour_paris(dt.datetime.fromtimestamp(ts, UTC)) == jour
except (ValueError, OverflowError, OSError):
continue
n_jour += dans_jour
n_24h += ts > now - 86400
return n_jour, n_24h
def _signaler(self, msg, maintenant):
if msg not in self._deja_signales:
self._deja_signales.add(msg)
try:
self.journal(msg, maintenant)
except Exception:
pass
def etat(self, maintenant):
c, s = self._commun(maintenant), self._site(maintenant)
rj, r24 = self._relais(maintenant)
return {"commun_jour": c["requetes"], "relais_jour": rj, "relais_24h": r24,
"total_jour": c["requetes"] + rj, "plafond_commun": self.cfg.plafond_commun,
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)
# Jour de Paris : compteur commun + relais. 24 h glissantes : le commun n'est pas horodaté, on prend donc
# les appels horodatés connus (site + relais), sous-estimation possible des autres appels du collecteur.
return (e["total_jour"] + n <= self.cfg.plafond_commun
and e["site_24h"] + e["relais_24h"] + n <= self.cfg.plafond_commun
and e["site_jour"] + n <= self.cfg.plafond_site and e["site_24h"] + n <= self.cfg.plafond_site)
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)
+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
-1
Voir le fichier
@@ -17,7 +17,6 @@ def config(dossier, **kw):
d = Path(dossier)
# Environnement simulé (dictionnaire) : les valeurs fictives ne sont jamais écrites sur disque.
env = {"MC_BASE": str(d), "MC_QUOTA_COMMUN": str(d / "quota.json"),
"MC_JOURNAL_RELAIS": "",
"MC_JETON_INFOCLIMAT": JETON_FICTIF, "MC_CLE_ROMMA": CLE_FICTIVE}
cfg = Config.depuis_env(env)
for k, v in kw.items():
+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}]}]}
-120
Voir le fichier
@@ -1,120 +0,0 @@
"""Quota : appels GWS via le relais SSH (journal `~/gws-relais/journal/appels.log`). Hors ligne, fichiers temporaires."""
import tempfile
import unittest
from pathlib import Path
from meteo_collecte import infoclimat as ic
from meteo_collecte.commun import Config, ecrire_json
from tests.aide import config, t
MAINTENANT = t(12, 0, jour=18) # 18/10/2026 12:00 UTC = 14:00 Paris (CEST)
MINUIT_PARIS = t(22, 0, jour=17) # 18/10 00:00 Paris
NOM = "TWFjIGRlIFRoZW8="
def ligne(ts, ident="a1b2c3d4e5f60718", couleur=3):
return "%d %s %d %s" % (int(ts.timestamp()), ident, couleur, NOM)
class TestQuotaRelais(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.cfg, self.journal = config(self.tmp.name)
self.fichier = Path(self.tmp.name) / "appels.log"
self.cfg.journal_relais = self.fichier
def tearDown(self):
self.tmp.cleanup()
def ecrire(self, *lignes):
self.fichier.write_text("\n".join(lignes) + "\n", encoding="utf-8")
def texte_journal(self):
f = self.cfg.base / "var" / "journal.log"
return f.read_text(encoding="utf-8") if f.exists() else ""
def etat(self):
return ic.Quota(self.cfg, self.journal).etat(MAINTENANT)
def test_defaut_et_desactivation_de_la_config(self):
d = Config.depuis_env({"MC_BASE": self.tmp.name})
self.assertEqual(d.journal_relais, Path.home() / "gws-relais" / "journal" / "appels.log")
self.assertIsNone(Config.depuis_env({"MC_BASE": self.tmp.name, "MC_JOURNAL_RELAIS": ""}).journal_relais)
self.assertEqual(Config.depuis_env({"MC_JOURNAL_RELAIS": "/x/y.log"}).journal_relais, Path("/x/y.log"))
def test_journal_absent(self):
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"], e["total_jour"]), (0, 0, 0))
self.assertIn("absent", self.texte_journal())
def test_desactive_aucune_lecture_ni_message(self):
self.ecrire(ligne(t(11, 0, jour=18)))
self.cfg.journal_relais = None
self.assertEqual(self.etat()["relais_jour"], 0)
self.assertEqual(self.texte_journal(), "")
def test_journal_vide(self):
self.fichier.write_text("", encoding="utf-8")
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 0))
def test_journal_illisible(self):
self.cfg.journal_relais = Path(self.tmp.name) # un dossier : l'ouverture échoue
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 0))
self.assertIn("illisible", self.texte_journal())
def test_lignes_invalides_ignorees(self):
self.ecrire("", "n'importe quoi", "abc def 1 x", "-5 id 1 x", "99999999999999999999 id 1 x",
"1.5e9 id 1 x", "seul", ligne(t(11, 0, jour=18)))
self.fichier.write_bytes(self.fichier.read_bytes() + b"\xff\xfe\x00 garbage\n")
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (1, 1))
def test_hier_et_aujourd_hui(self):
self.ecrire(ligne(t(10, 0, jour=16)), # 2 jours avant : hors jour, hors 24 h
ligne(t(21, 59, jour=17)), # 17/10 23:59 Paris : hier, dans les 24 h
ligne(MINUIT_PARIS), # 18/10 00:00 Paris : aujourd'hui
ligne(t(11, 59, jour=18), ident="admin", couleur=0),
ligne(t(12, 5, jour=18))) # futur (> 60 s) : ignoré
e = self.etat()
self.assertEqual(e["relais_jour"], 2)
self.assertEqual(e["relais_24h"], 3)
def test_borne_24h(self):
self.ecrire(ligne(t(12, 0, jour=17)), # exactement 24 h avant : exclu
ligne(t(12, 1, jour=17)))
self.assertEqual(self.etat()["relais_24h"], 1)
def test_total_additionne_le_compteur_commun(self):
ecrire_json(self.cfg.quota_commun, {"date": "2026-10-18", "requetes": 100}, compact=False)
self.ecrire(*[ligne(t(11, 0, jour=18))] * 40)
e = self.etat()
self.assertEqual((e["commun_jour"], e["relais_jour"], e["total_jour"]), (100, 40, 140))
def test_plafond_atteint_par_le_total(self):
ecrire_json(self.cfg.quota_commun, {"date": "2026-10-18", "requetes": 4000}, compact=False)
q = ic.Quota(self.cfg, self.journal)
self.assertTrue(q.peut(1, MAINTENANT)) # sans relais : 4001 <= 4999
self.ecrire(*[ligne(t(11, 0, jour=18))] * 998)
self.assertTrue(q.peut(1, MAINTENANT)) # 4000 + 998 + 1 = 4999 : pile au plafond
self.assertFalse(q.peut(2, MAINTENANT))
self.ecrire(*[ligne(t(11, 0, jour=18))] * 999)
self.assertFalse(q.peut(1, MAINTENANT))
def test_plafond_atteint_par_les_24h_glissantes_seules(self):
# Le relais a fait 4999 appels hier soir (jour précédent) : le compteur du jour est à 0, mais 24 h pleines.
self.ecrire(*[ligne(t(21, 0, jour=17))] * 4999)
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 4999))
self.assertFalse(ic.Quota(self.cfg, self.journal).peut(1, MAINTENANT))
def test_message_signale_une_seule_fois(self):
q = ic.Quota(self.cfg, self.journal)
q.etat(MAINTENANT)
q.etat(MAINTENANT)
self.assertEqual(self.texte_journal().count("absent"), 1)
if __name__ == "__main__":
unittest.main()
+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()