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

+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()