Module Infoclimat economie de requetes

Requetes groupees par lots de 25, rythme mesure par station, passage
principal /10 min seulement si une station est due, rattrapage cible
des stations ponctuelles, fenetre courte, quota commun + plafond site
1000/jour et 24 h glissantes, alerte 80 % sans envoi reel, pause 15 min.
Tests hors ligne sur reponses fabriquees.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Opus 5.5 a révisé 2026-10-16 18:57:57 +02:00
1 Parent 34c1bf6736
révision 017dfd9728
6 fichiers modifiés
+699

Aucun fichier ne correspond à votre recherche

+101
Voir le fichier
@@ -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"
}
}
}
+291
Voir le fichier
@@ -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
+46
Voir le fichier
@@ -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)
+1
Voir le fichier
@@ -0,0 +1 @@
{"status": "KO", "errors": ["invalid token"]}
+68
Voir le fichier
@@ -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
}
]
}
}
+192
Voir le fichier
@@ -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"<html>", ["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()