diff --git a/config/stations.json b/config/stations.json new file mode 100644 index 0000000..d3e9403 --- /dev/null +++ b/config/stations.json @@ -0,0 +1,101 @@ +{ + "_note": "Stations Infoclimat suivies (phase 1, 24 stations). ROMMA : toutes les stations ouvertes sur la clé (global=1).", + "infoclimat": { + "000T0": { + "nom": "Lans-en-Vercors – Les Bruyères", + "licence": "CC BY" + }, + "000GS": { + "nom": "Lans-en-Vercors – Les Allières", + "licence": "CC BY-NC" + }, + "000HT": { + "nom": "Engins", + "licence": "CC BY" + }, + "000UF": { + "nom": "La Chapelle-en-Vercors – Combe-de-l'Oscence", + "licence": "CC BY-NC" + }, + "000QU": { + "nom": "Brion", + "licence": "CC BY" + }, + "000PD": { + "nom": "Die", + "licence": "CC BY-NC" + }, + "000OS": { + "nom": "Saint-Julien-en-Quint", + "licence": "CC BY-NC" + }, + "STATIC0479": { + "nom": "Crête de la Moucherolle", + "licence": "CC BY-NC" + }, + "STATIC0213": { + "nom": "Combe de Darbounouse", + "licence": "CC BY-NC" + }, + "000IA": { + "nom": "Méaudre", + "licence": "CC BY" + }, + "000IL": { + "nom": "Autrans (Gêve)", + "licence": "CC BY" + }, + "00014": { + "nom": "Saint-Martin-d'Hères", + "licence": "CC BY-NC" + }, + "ME102": { + "nom": "Vizille – Collège Les Mattons", + "licence": "CC BY" + }, + "000SD": { + "nom": "Theys (850 m)", + "licence": "CC BY-NC" + }, + "STATIC0342": { + "nom": "Lumbin", + "licence": "CC BY-NC" + }, + "STATIC0216": { + "nom": "Saint-Pancrasse", + "licence": "CC BY-NC" + }, + "000BN": { + "nom": "Voiron – Centre-ville", + "licence": "CC BY" + }, + "STATIC0247": { + "nom": "Saint-Christophe-sur-Guiers", + "licence": "CC BY" + }, + "00094": { + "nom": "Miribel-les-Échelles", + "licence": "CC BY" + }, + "STATIC0238": { + "nom": "Rochechinard", + "licence": "CC BY-NC" + }, + "000O9": { + "nom": "Recoubeau-Jansac", + "licence": "CC BY-NC" + }, + "000ZK": { + "nom": "Châtillon-en-Diois – Cirque d'Archiane", + "licence": "CC BY-NC" + }, + "STATIC0203": { + "nom": "Marignac-en-Diois", + "licence": "CC BY-NC" + }, + "STATIC0323": { + "nom": "Solaure-en-Diois", + "licence": "CC BY-NC" + } + } +} \ No newline at end of file diff --git a/meteo_collecte/infoclimat.py b/meteo_collecte/infoclimat.py new file mode 100644 index 0000000..2f84ff7 --- /dev/null +++ b/meteo_collecte/infoclimat.py @@ -0,0 +1,291 @@ +"""Source Infoclimat (open data v2), d'après ~/meteo-direct/direct.py et les règles d'économie du §2.2. + +1. Requêtes groupées : toutes les stations dues dans une seule requête (`stations[]=` répété), lots de 25. +2. Rythme par station *mesuré* dans la base (pas réel 10/15/20 min) ; due à dernière + pas + délai de publication. +3. Un passage principal toutes les 10 min (hh:x4), seulement si au moins une station est due. +4. Rattrapage ciblé (hh:x9) : seulement les stations ponctuelles manquées au passage principal. +5. Fenêtre courte : start=end=aujourd'hui UTC ; la veille seulement au premier passage après minuit UTC. +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 (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. +""" +import datetime as dt +import gzip +import json +import statistics +import urllib.parse +import urllib.request + +from .commun import UTC, Pause, ecrire_json, fmt_utc, jour_paris, lire_json, lire_secret, lire_utc, scrub + +SOURCE = "infoclimat" +URL_BASE = "https://www.infoclimat.fr/opendata/" +UA = "weather.gastinel.me/0.1 (meteo-collecte)" +DELAI_PUBLICATION_S = 120 # mesuré le 02/10 : ~2 min entre l'instant de mesure et la mise en ligne +PAS_DEFAUT_S = 600 +PAS_MIN_S, PAS_MAX_S = 600, 3600 +RETARD_PONCTUEL_S = 9 * 60 # [À VÉRIFIER] seuil « habituellement ponctuelle » (médiane réception - mesure) +ECART_MIN_PRINCIPAL_S = 8 * 60 + +# Champs Infoclimat -> colonnes du stockage (pluie_cumul_0h : cumul depuis 0 h, [À VÉRIFIER] UTC ou Paris) +CORRESPONDANCE = {"temperature": "temperature", "humidite": "humidite", "point_de_rosee": "point_de_rosee", + "pression": "pression", "vent_moyen": "vent_moyen", "vent_rafales": "vent_rafales", + "vent_direction": "vent_direction", "pluie_1h": "pluie_1h", "pluie_cumul_0h": "pluie_cumul"} + + +class ErreurInfoclimat(Exception): + pass + + +# --------------------------------------------------------------------------- +# Quota +# --------------------------------------------------------------------------- + +class Quota: + """Deux compteurs : le commun (même format que direct.py et le collecteur GWS) et celui du site.""" + + def __init__(self, cfg, journal, envoyer_alerte=None): + self.cfg = cfg + self.journal = journal + self.fichier_site = cfg.base / "var" / "quota_site.json" + self.envoyer_alerte = envoyer_alerte or (lambda texte: envoyer_ntfy(cfg, texte)) + + def _commun(self, maintenant): + j = jour_paris(maintenant) + q = lire_json(self.cfg.quota_commun, {}) + if q.get("date") != j: + q = {"date": j, "requetes": 0} + return q + + def _site(self, maintenant): + j = jour_paris(maintenant) + s = lire_json(self.fichier_site, {}) + if s.get("date") != j: + s = {"date": j, "requetes": 0, "alerte_le": s.get("alerte_le"), "horodatages": s.get("horodatages", [])} + limite = maintenant.timestamp() - 86400 + s["horodatages"] = [t for t in s.get("horodatages", []) if t > limite] + return s + + def etat(self, maintenant): + c, s = self._commun(maintenant), self._site(maintenant) + 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) + 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) + c["requetes"] += n + ecrire_json(self.cfg.quota_commun, c, compact=False) + s = self._site(maintenant) + s["requetes"] += n + s["horodatages"].extend([maintenant.timestamp()] * n) + usage = max(s["requetes"], len(s["horodatages"])) + if usage >= self.cfg.seuil_alerte * self.cfg.plafond_site and s.get("alerte_le") != s["date"]: + s["alerte_le"] = s["date"] + texte = "Infoclimat : %d requêtes du site (jour %d, 24 h %d) sur un plafond de %d" % ( + usage, s["requetes"], len(s["horodatages"]), self.cfg.plafond_site) + self.journal("ALERTE quota " + texte, maintenant) + try: + self.envoyer_alerte(texte) + except Exception as e: # une alerte ratée ne bloque jamais la collecte + self.journal("alerte non envoyée : %s" % str(e)[:200], maintenant) + ecrire_json(self.fichier_site, s) + return c["requetes"] + + +def envoyer_ntfy(cfg, texte): + """Prévu mais inactif : rien n'est envoyé tant que MC_ALERTE_ACTIVE n'est pas à 1 et MC_NTFY_URL vide.""" + if not (cfg.alerte_active and cfg.ntfy_url): + return False + req = urllib.request.Request(cfg.ntfy_url, data=texte.encode("utf-8"), headers={"Title": "meteo-collecte"}) + urllib.request.urlopen(req, timeout=20).read() + return True + + +# --------------------------------------------------------------------------- +# Rythme des stations +# --------------------------------------------------------------------------- + +def mesurer_rythme(instants): + """[(dh_utc, recu_utc)...] -> (pas_s, retard_s). Pas = médiane des écarts, arrondi à 5 min, borné.""" + dhs = [lire_utc(d) for d, _ in instants] + ecarts = [(b - a).total_seconds() for a, b in zip(dhs, dhs[1:]) if b > a] + if len(ecarts) >= 2: + pas = round(statistics.median(ecarts) / 300) * 300 + pas = int(min(max(pas, PAS_MIN_S), PAS_MAX_S)) + else: + pas = PAS_DEFAUT_S + retards = [(lire_utc(r) - lire_utc(d)).total_seconds() for d, r in instants] + retard = statistics.median(retards) if retards else None + return pas, retard + + +def rythmes(stockage, ids): + r = {} + for sid in ids: + inst = stockage.instants(SOURCE, sid, 30) + pas, retard = mesurer_rythme(inst) + r[sid] = {"derniere": lire_utc(inst[-1][0]) if inst else None, "pas_s": pas, "retard_s": retard} + return r + + +def est_due(r, maintenant): + if r["derniere"] is None: + return True + return maintenant >= r["derniere"] + dt.timedelta(seconds=r["pas_s"] + DELAI_PUBLICATION_S) + + +def est_ponctuelle(r): + return r["retard_s"] is not None and r["retard_s"] <= RETARD_PONCTUEL_S + + +def type_passage(maintenant): + """hh:x4..x8 -> passage principal ; hh:x9..x3 -> rattrapage (le minuteur tire à x4 et x9).""" + return "principal" if (maintenant.minute - 4) % 10 < 5 else "rattrapage" + + +def planifier(etat, rythmes_st, maintenant): + """Renvoie (type, [stations à demander]). Liste vide = aucun appel.""" + genre = type_passage(maintenant) + dues = [sid for sid, r in rythmes_st.items() if est_due(r, maintenant)] + if genre == "principal": + dernier = etat.get("dernier_principal_utc") + if dernier and (maintenant - lire_utc(dernier)).total_seconds() < ECART_MIN_PRINCIPAL_S: + return genre, [] + return genre, dues + cibles = [sid for sid in etat.get("manquees", []) + if sid in rythmes_st and sid in dues and est_ponctuelle(rythmes_st[sid])] + return genre, cibles + + +def fenetre(etat, maintenant, stations, rythmes_st): + """start=end=aujourd'hui UTC ; veille ajoutée au premier passage après minuit UTC ou pour une station + sans donnée récente.""" + auj = maintenant.date() + veille = etat.get("dernier_jour_utc") != str(auj) or any( + rythmes_st[s]["derniere"] is None or rythmes_st[s]["derniere"].date() < auj for s in stations) + return (auj - dt.timedelta(days=1) if veille else auj), auj + + +def construire_url(stations, debut, fin, jeton): + return (URL_BASE + "?version=2&method=get&format=json&" + + "&".join("stations[]=" + urllib.parse.quote(s) for s in stations) + + "&start=%s&end=%s&token=%s" % (debut, fin, urllib.parse.quote(jeton, safe=""))) + + +def telecharger(url): + r = urllib.request.urlopen(urllib.request.Request( + url, headers={"User-Agent": UA, "Accept-Encoding": "gzip"}), timeout=120) + brut = r.read() + if r.headers.get("Content-Encoding") == "gzip": + brut = gzip.decompress(brut) + return brut + + +def lire_reponse(brut, demandees): + """-> ({station: [mesures]}, {station: métadonnées}). Lève ErreurInfoclimat si le statut n'est pas OK.""" + try: + d = json.loads(brut) + except ValueError: + raise ErreurInfoclimat("réponse non JSON") + if not isinstance(d, dict) or str(d.get("status", "")).upper() != "OK": + err = d.get("errors") if isinstance(d, dict) else d + raise ErreurInfoclimat("statut non OK : %s" % str(err)[:200]) + mesures = {} + horaire = d.get("hourly") or {} + for sid in demandees: + lignes = horaire.get(sid) if isinstance(horaire, dict) else None + mesures[sid] = [dict({"dh_utc": x["dh_utc"]}, **{c: x.get(k) for k, c in CORRESPONDANCE.items()}) + for x in (lignes or []) if isinstance(x, dict) and "dh_utc" in x] + meta = {} + for m in d.get("stations") or []: + if isinstance(m, dict) and m.get("id") in demandees: + meta[m["id"]] = {"altitude": m.get("elevation"), "lat": m.get("latitude"), "lon": m.get("longitude"), + "licence": (m.get("license") or {}).get("license", ""), "nom_ic": m.get("name")} + return mesures, meta + + +# --------------------------------------------------------------------------- +# Passage +# --------------------------------------------------------------------------- + +def passer(cfg, stockage, journal, maintenant, stations_cfg, fetch=telecharger, quota=None): + """Un tick Infoclimat. Renvoie un petit résumé (dict) pour etat.json.""" + var = cfg.base / "var" + fichier_etat = var / "etat_infoclimat.json" + etat = lire_json(fichier_etat, {}) + pause = Pause(var / "pause_infoclimat.txt") + quota = quota or Quota(cfg, journal) + resume = {"source": SOURCE, "action": "rien", "requetes": 0} + if pause.active(maintenant): + resume.update(action="pause", jusqua=fmt_utc(pause.jusqua())) + return resume + + for sid, info in stations_cfg.items(): + stockage.maj_station(SOURCE, sid, nom=info.get("nom"), licence=info.get("licence"), lien=info.get("lien")) + r = rythmes(stockage, list(stations_cfg)) + genre, cibles = planifier(etat, r, maintenant) + resume["type"] = genre + if not cibles: + return resume + + try: + jeton = lire_secret(cfg.jeton_infoclimat) + except OSError: + journal("jeton Infoclimat illisible, aucun appel", maintenant) + resume["action"] = "sans_jeton" + return resume + journal.masquer(jeton) + + nouvelles_total, recues, ok = 0, set(), False + for i in range(0, len(cibles), cfg.lot_max): + lot = cibles[i:i + cfg.lot_max] + cout = len(lot) if cfg.compte_par_station else 1 + if not quota.peut(cout, maintenant): + journal("plafond atteint (%s), aucun appel" % quota.etat(maintenant), maintenant) + resume["action"] = "plafond" + break + debut, fin = fenetre(etat, maintenant, lot, r) + n = quota.noter(cout, maintenant) + resume["requetes"] += cout + try: + mesures, meta = lire_reponse(fetch(construire_url(lot, debut, fin, jeton)), lot) + except Exception as e: # toute erreur = arrêt avec pause de 15 min (décision de Théo) + pause.poser(maintenant) + journal("ERREUR Infoclimat (requête %d du jour) : %s ; pause 15 min" + % (n, scrub(str(e), jeton)[:300]), maintenant) + resume["action"] = "erreur" + resume["erreur"] = scrub(str(e), jeton)[:200] + break + for sid in lot: + nv = stockage.ajouter(SOURCE, sid, mesures.get(sid, []), maintenant) + if nv: + recues.add(sid) + nouvelles_total += nv + if sid in meta: + m = meta[sid] + stockage.maj_station(SOURCE, sid, lat=m["lat"], lon=m["lon"], altitude=m["altitude"], + licence=m["licence"]) + ok = True + resume["action"] = "appel" + + if ok: + etat["dernier_jour_utc"] = str(maintenant.date()) + etat["dernier_succes_utc"] = fmt_utc(maintenant) + if genre == "principal": + etat["dernier_principal_utc"] = fmt_utc(maintenant) + etat["manquees"] = [s for s in cibles if s not in recues] + else: + etat["manquees"] = [s for s in etat.get("manquees", []) if s not in recues] + ecrire_json(fichier_etat, etat, compact=False) + journal("ok %s : %d station(s) demandée(s), %d avec du neuf, %d mesure(s) nouvelle(s) ; quota %s" + % (genre, len(cibles), len(recues), nouvelles_total, quota.etat(maintenant)), maintenant) + resume.update(demandees=len(cibles), nouvelles=nouvelles_total) + return resume diff --git a/tests/aide.py b/tests/aide.py new file mode 100644 index 0000000..3a41d49 --- /dev/null +++ b/tests/aide.py @@ -0,0 +1,46 @@ +"""Aides de test : configuration dans un dossier temporaire, faux réseau. Aucun appel réel, aucun vrai secret.""" +import datetime as dt +from pathlib import Path + +from meteo_collecte.commun import UTC, Config, Journal + +FIXTURES = Path(__file__).resolve().parent / "fixtures" +JETON_FICTIF = "JETON+FICTIF/123=" # fabriqué pour les tests +CLE_FICTIVE = "CLE+FICTIVE/456=" + + +def fixture(nom): + return (FIXTURES / nom).read_bytes() + + +def config(dossier, **kw): + d = Path(dossier) + (d / "secrets").mkdir(exist_ok=True) + (d / "secrets" / "infoclimat.token").write_text(JETON_FICTIF) + (d / "secrets" / "romma.key").write_text(CLE_FICTIVE) + env = {"MC_BASE": str(d), "MC_QUOTA_COMMUN": str(d / "quota.json"), + "MC_JETON_INFOCLIMAT": str(d / "secrets" / "infoclimat.token"), + "MC_CLE_ROMMA": str(d / "secrets" / "romma.key")} + cfg = Config.depuis_env(env) + for k, v in kw.items(): + setattr(cfg, k, v) + return cfg, Journal(d / "var" / "journal.log") + + +class FauxReseau: + """Remplace urllib : renvoie des réponses enregistrées et garde les URL demandées.""" + + def __init__(self, *reponses): + self.reponses = list(reponses) + self.urls = [] + + def __call__(self, url): + self.urls.append(url) + r = self.reponses.pop(0) if len(self.reponses) > 1 else self.reponses[0] + if isinstance(r, Exception): + raise r + return r + + +def t(h, m, jour=16, mois=10): + return dt.datetime(2026, mois, jour, h, m, tzinfo=UTC) diff --git a/tests/fixtures/infoclimat_erreur.json b/tests/fixtures/infoclimat_erreur.json new file mode 100644 index 0000000..a829511 --- /dev/null +++ b/tests/fixtures/infoclimat_erreur.json @@ -0,0 +1 @@ +{"status": "KO", "errors": ["invalid token"]} \ No newline at end of file diff --git a/tests/fixtures/infoclimat_ok.json b/tests/fixtures/infoclimat_ok.json new file mode 100644 index 0000000..d1d0fe2 --- /dev/null +++ b/tests/fixtures/infoclimat_ok.json @@ -0,0 +1,68 @@ +{ + "status": "OK", + "errors": [], + "stations": [ + { + "id": "000T0", + "name": "Lans", + "latitude": 45.1, + "longitude": 5.58, + "elevation": 990, + "license": { + "license": "CC BY" + } + }, + { + "id": "000IL", + "name": "Autrans", + "latitude": 45.17, + "longitude": 5.54, + "elevation": 1353, + "license": { + "license": "CC BY" + } + } + ], + "hourly": { + "_params": [ + "dh_utc", + "temperature" + ], + "000T0": [ + { + "id_station": "000T0", + "dh_utc": "2026-10-16 11:40:00", + "temperature": "7.2", + "humidite": "81", + "pression": "1021.3", + "vent_moyen": "3.1", + "vent_rafales": "9.4", + "vent_direction": "200", + "pluie_1h": "0", + "pluie_cumul_0h": "0.2", + "point_de_rosee": "4.1" + }, + { + "id_station": "000T0", + "dh_utc": "2026-10-16 11:50:00", + "temperature": "7.5", + "humidite": "80", + "pression": "1021.2", + "vent_moyen": "2.8", + "vent_rafales": "8.0", + "vent_direction": "210", + "pluie_1h": "0", + "pluie_cumul_0h": "0.2", + "point_de_rosee": "4.2" + } + ], + "000IL": [ + { + "id_station": "000IL", + "dh_utc": "2026-10-16 11:40:00", + "temperature": "4.0", + "humidite": null + } + ] + } +} \ No newline at end of file diff --git a/tests/test_infoclimat.py b/tests/test_infoclimat.py new file mode 100644 index 0000000..2979305 --- /dev/null +++ b/tests/test_infoclimat.py @@ -0,0 +1,192 @@ +import json +import tempfile +import unittest +import urllib.parse +from pathlib import Path + +from meteo_collecte import infoclimat as ic +from meteo_collecte.commun import lire_json +from meteo_collecte.stockage import Stockage +from tests.aide import JETON_FICTIF, FauxReseau, config, fixture, t + +STATIONS = {"000T0": {"nom": "Lans", "licence": "CC BY"}, "000IL": {"nom": "Autrans", "licence": "CC BY"}} + + +def instants(debut_min, pas_min, n, retard_min=2): + """Fabrique [(dh_utc, recu_utc)] à partir de 10:00 UTC le 16/10.""" + out = [] + for i in range(n): + m = debut_min + i * pas_min + out.append(("2026-10-16 %02d:%02d:00" % (10 + m // 60, m % 60), + "2026-10-16 %02d:%02d:00" % (10 + (m + retard_min) // 60, (m + retard_min) % 60))) + return out + + +class TestRythme(unittest.TestCase): + def test_pas_mesure(self): + self.assertEqual(ic.mesurer_rythme(instants(0, 10, 6))[0], 600) + self.assertEqual(ic.mesurer_rythme(instants(0, 15, 6))[0], 900) + self.assertEqual(ic.mesurer_rythme(instants(0, 20, 5))[0], 1200) + self.assertEqual(ic.mesurer_rythme([])[0], 600) + + def test_retard_et_ponctualite(self): + pas, retard = ic.mesurer_rythme(instants(0, 10, 6, retard_min=14)) + self.assertEqual(retard, 14 * 60) + self.assertFalse(ic.est_ponctuelle({"retard_s": retard})) + self.assertTrue(ic.est_ponctuelle({"retard_s": 240})) + + def test_due(self): + r = {"derniere": t(11, 50), "pas_s": 600, "retard_s": 120} + self.assertFalse(ic.est_due(r, t(12, 1))) + self.assertTrue(ic.est_due(r, t(12, 2))) + r15 = {"derniere": t(11, 45), "pas_s": 900, "retard_s": 120} + self.assertFalse(ic.est_due(r15, t(11, 54))) # une station à 15 min n'est pas prise à chaque passage + self.assertTrue(ic.est_due(r15, t(12, 4))) + + def test_type_passage(self): + self.assertEqual(ic.type_passage(t(12, 4)), "principal") + self.assertEqual(ic.type_passage(t(12, 9)), "rattrapage") + self.assertEqual(ic.type_passage(t(12, 14)), "principal") + + def test_planifier_rien_si_aucune_due(self): + r = {"A": {"derniere": t(12, 0), "pas_s": 600, "retard_s": 60}} + self.assertEqual(ic.planifier({}, r, t(12, 4)), ("principal", [])) + + def test_rattrapage_cible_seulement_les_ponctuelles_manquees(self): + r = {"P": {"derniere": t(11, 50), "pas_s": 600, "retard_s": 120}, # ponctuelle, manquée + "L": {"derniere": t(11, 50), "pas_s": 600, "retard_s": 840}, # toujours en retard + "X": {"derniere": t(11, 50), "pas_s": 600, "retard_s": 120}} # due mais pas manquée + genre, cibles = ic.planifier({"manquees": ["P", "L"]}, r, t(12, 9)) + self.assertEqual((genre, cibles), ("rattrapage", ["P"])) + + def test_pas_deux_principaux_rapproches(self): + r = {"A": {"derniere": None, "pas_s": 600, "retard_s": None}} + self.assertEqual(ic.planifier({"dernier_principal_utc": "2026-10-16 12:04:00"}, r, t(12, 8))[1], []) + + def test_fenetre_courte(self): + r = {"A": {"derniere": t(11, 50)}} + self.assertEqual(ic.fenetre({"dernier_jour_utc": "2026-10-16"}, t(12, 4), ["A"], r), + (t(0, 0).date(), t(0, 0).date())) + # premier passage après minuit UTC : la veille est ajoutée + self.assertEqual(ic.fenetre({"dernier_jour_utc": "2026-10-15"}, t(0, 4), ["A"], r)[0].isoformat(), + "2026-10-15") + + +class TestReponse(unittest.TestCase): + def test_lecture_fixture(self): + m, meta = ic.lire_reponse(fixture("infoclimat_ok.json"), ["000T0", "000IL", "000GS"]) + self.assertEqual(len(m["000T0"]), 2) + self.assertEqual(m["000T0"][1]["pluie_cumul"], "0.2") + self.assertEqual(m["000GS"], []) + self.assertEqual(meta["000T0"]["altitude"], 990) + + def test_statut_non_ok_meme_en_200(self): + with self.assertRaises(ic.ErreurInfoclimat): + ic.lire_reponse(fixture("infoclimat_erreur.json"), ["000T0"]) + with self.assertRaises(ic.ErreurInfoclimat): + ic.lire_reponse(b"", ["000T0"]) + + def test_url_groupee(self): + u = ic.construire_url(["000T0", "STATIC0479"], "2026-10-16", "2026-10-16", JETON_FICTIF) + self.assertEqual(u.count("stations[]="), 2) + self.assertIn("start=2026-10-16&end=2026-10-16", u) + self.assertIn("token=" + urllib.parse.quote(JETON_FICTIF, safe=""), u) + + +class TestPassage(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.cfg, self.journal = config(self.tmp.name) + self.st = Stockage(Path(self.tmp.name) / "m.sqlite") + self.alertes = [] + + def tearDown(self): + self.st.fermer() + self.tmp.cleanup() + + def quota(self): + return ic.Quota(self.cfg, self.journal, envoyer_alerte=self.alertes.append) + + def passer(self, quand, reseau): + return ic.passer(self.cfg, self.st, self.journal, quand, STATIONS, fetch=reseau, quota=self.quota()) + + def test_une_seule_requete_pour_toutes_les_stations(self): + r = FauxReseau(fixture("infoclimat_ok.json")) + res = self.passer(t(12, 4), r) + self.assertEqual(len(r.urls), 1) + self.assertEqual(res["requetes"], 1) + self.assertEqual(self.st.compter("infoclimat"), 3) + self.assertEqual(lire_json(self.cfg.quota_commun, {})["requetes"], 1) + # 000IL n'a rien de neuf après 11:40 ? Elle a reçu une mesure : pas manquée. + self.assertEqual(lire_json(self.cfg.base / "var" / "etat_infoclimat.json", {})["manquees"], []) + + def test_aucun_appel_si_rien_n_est_du(self): + r = FauxReseau(fixture("infoclimat_ok.json")) + self.passer(t(12, 4), r) + r2 = FauxReseau(fixture("infoclimat_ok.json")) + res = self.passer(t(12, 4).replace(second=30), r2) # même passage : bloqué + self.assertEqual(r2.urls, []) + self.assertEqual(res["requetes"], 0) + + def test_erreur_pause_15_min_et_jeton_masque(self): + r = FauxReseau(OSError("échec pour url https://x/?token=%s" % urllib.parse.quote(JETON_FICTIF, safe=""))) + res = self.passer(t(12, 4), r) + self.assertEqual(res["action"], "erreur") + journal = (self.cfg.base / "var" / "journal.log").read_text(encoding="utf-8") + self.assertIn("pause 15 min", journal) + self.assertNotIn("FICTIF", journal) + self.assertNotIn("FICTIF", json.dumps(res)) + r2 = FauxReseau(fixture("infoclimat_ok.json")) + self.assertEqual(self.passer(t(12, 14), r2)["action"], "pause") + self.assertEqual(r2.urls, []) + self.assertEqual(self.passer(t(12, 24), r2)["action"], "appel") + + def test_plafond_site(self): + self.cfg.plafond_site = 1 + self.passer(t(12, 4), FauxReseau(fixture("infoclimat_ok.json"))) + r2 = FauxReseau(fixture("infoclimat_ok.json")) + res = self.passer(t(13, 4), r2) + self.assertEqual(res["action"], "plafond") + self.assertEqual(r2.urls, []) + + def test_plafond_commun(self): + self.cfg.quota_commun.write_text(json.dumps({"date": "2026-10-16", "requetes": 4999})) + r = FauxReseau(fixture("infoclimat_ok.json")) + self.assertEqual(self.passer(t(12, 4), r)["action"], "plafond") + self.assertEqual(r.urls, []) + + def test_compteur_24h_glissantes(self): + q = self.quota() + self.cfg.plafond_site = 3 + for h in (19, 20, 21): + q.noter(1, t(h, 0, jour=15)) + # nouveau jour de Paris (16/10) mais 3 requêtes dans les 24 h : refus + self.assertEqual(q.etat(t(12, 0))["site_jour"], 0) + self.assertFalse(q.peut(1, t(12, 0))) + self.assertTrue(q.peut(1, t(20, 30))) + + def test_alerte_80_pour_cent_une_fois_par_jour(self): + self.cfg.plafond_site = 10 + q = self.quota() + for i in range(10): + q.noter(1, t(12, i)) + self.assertEqual(len(self.alertes), 1) + self.assertIn("8 requêtes", self.alertes[0]) + + def test_envoi_ntfy_desactive_par_defaut(self): + self.assertFalse(ic.envoyer_ntfy(self.cfg, "test")) + + def test_compte_par_station(self): + self.cfg.compte_par_station = True + res = self.passer(t(12, 4), FauxReseau(fixture("infoclimat_ok.json"))) + self.assertEqual(res["requetes"], 2) + + def test_lots_de_25(self): + self.cfg.lot_max = 1 + r = FauxReseau(fixture("infoclimat_ok.json")) + self.passer(t(12, 4), r) + self.assertEqual(len(r.urls), 2) + + +if __name__ == "__main__": + unittest.main()