diff --git a/meteo_collecte/infoclimat.py b/meteo_collecte/infoclimat.py index ebec2d0..793feec 100644 --- a/meteo_collecte/infoclimat.py +++ b/meteo_collecte/infoclimat.py @@ -2,6 +2,7 @@ 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. +2bis. `frequence_min` (dashboard) : due après max(frequence_min, rythme mesuré) ; absent = comportement d'avant. 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. @@ -29,6 +30,7 @@ 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 +FREQ_MIN_MIN, FREQ_MIN_MAX = 5, 1440 # bornes de frequence_min, comme la validation du dashboard meteo-lan # 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", @@ -127,19 +129,43 @@ def mesurer_rythme(instants): return pas, retard -def rythmes(stockage, ids): +def frequences_configurees(stations_cfg, journal=None, maintenant=None): + """Fréquence réglée dans le dashboard (`frequence_min`, entier 5 à 1440) -> {station: secondes}. + Champ absent : station ignorée ici (comportement inchangé). Valeur invalide : ignorée, une ligne de journal.""" + out = {} + for sid, info in stations_cfg.items(): + if not isinstance(info, dict) or "frequence_min" not in info: + continue + f = info["frequence_min"] + if isinstance(f, bool) or not isinstance(f, int) or not (FREQ_MIN_MIN <= f <= FREQ_MIN_MAX): + if journal: + journal("frequence_min invalide pour %s (%r : entier %d à %d attendu), ignorée" + % (str(sid)[:40], str(f)[:40], FREQ_MIN_MIN, FREQ_MIN_MAX), maintenant) + continue + out[sid] = f * 60 + return out + + +def rythmes(stockage, ids, frequences=None): 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} + if frequences and sid in frequences: + r[sid]["frequence_s"] = frequences[sid] return r +def pas_effectif_s(r): + """Pas mesuré, relevé à la fréquence réglée si elle est plus lente (jamais plus vite que la station).""" + return max(r["pas_s"], r.get("frequence_s") or 0) + + 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) + return maintenant >= r["derniere"] + dt.timedelta(seconds=pas_effectif_s(r) + DELAI_PUBLICATION_S) def est_ponctuelle(r): @@ -230,7 +256,7 @@ def passer(cfg, stockage, journal, maintenant, stations_cfg, fetch=telecharger, 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)) + r = rythmes(stockage, list(stations_cfg), frequences_configurees(stations_cfg, journal, maintenant)) genre, cibles = planifier(etat, r, maintenant) resume["type"] = genre if not cibles: diff --git a/tests/test_frequence.py b/tests/test_frequence.py new file mode 100644 index 0000000..978e3bb --- /dev/null +++ b/tests/test_frequence.py @@ -0,0 +1,162 @@ +"""frequence_min (réglée dans le dashboard meteo-lan) : due après max(frequence_min, rythme mesuré). Hors ligne.""" +import datetime as dt +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 UTC +from meteo_collecte.stockage import Stockage +from tests.aide import config, t + + +def r(derniere, pas_s=600, **kw): + return dict({"derniere": derniere, "pas_s": pas_s, "retard_s": 120}, **kw) + + +class TestValidation(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.cfg, self.journal = config(self.tmp.name) + + def tearDown(self): + self.tmp.cleanup() + + def lire_journal(self): + return self.journal.fichier.read_text(encoding="utf-8") if self.journal.fichier.exists() else "" + + def test_valeurs_valides(self): + f = ic.frequences_configurees({"a": {"frequence_min": 5}, "b": {"frequence_min": 60}, + "c": {"frequence_min": 1440}}, self.journal, t(12, 4)) + self.assertEqual(f, {"a": 300, "b": 3600, "c": 86400}) + self.assertEqual(self.lire_journal(), "") + + def test_champ_absent_ignore_sans_journal(self): + self.assertEqual(ic.frequences_configurees({"a": {"nom": "x"}}, self.journal, t(12, 4)), {}) + self.assertEqual(self.lire_journal(), "") + + def test_valeurs_invalides_ignorees_avec_une_ligne_chacune(self): + mauvaises = [4, 1441, 0, -10, 30.5, "30", None, True, [30]] + stations = {"s%d" % i: {"frequence_min": v} for i, v in enumerate(mauvaises)} + self.assertEqual(ic.frequences_configurees(stations, self.journal, t(12, 4)), {}) + lignes = self.lire_journal().strip().splitlines() + self.assertEqual(len(lignes), len(mauvaises)) + self.assertTrue(all("frequence_min invalide" in x for x in lignes)) + + def test_entree_non_dictionnaire_ne_plante_pas(self): + self.assertEqual(ic.frequences_configurees({"a": "texte", "b": None}, self.journal, t(12, 4)), {}) + + +class TestDue(unittest.TestCase): + def test_sans_champ_comportement_inchange(self): + d = t(12, 0) + self.assertFalse(ic.est_due(r(d), t(12, 11))) + self.assertTrue(ic.est_due(r(d), t(12, 12))) + + def test_frequence_plus_lente_que_la_station(self): + d = t(12, 0) + st = r(d, 600, frequence_s=1800) + self.assertFalse(ic.est_due(st, t(12, 31))) + self.assertTrue(ic.est_due(st, t(12, 32))) # 30 min + 2 min de publication + + def test_jamais_plus_souvent_que_la_station(self): + d = t(12, 0) + st = r(d, 1800, frequence_s=300) # station lente (30 min), réglage 5 min + self.assertEqual(ic.pas_effectif_s(st), 1800) + self.assertFalse(ic.est_due(st, t(12, 20))) + self.assertTrue(ic.est_due(st, t(12, 32))) + + def test_jamais_vue_toujours_due(self): + self.assertTrue(ic.est_due(r(None, 600, frequence_s=3600), t(12, 4))) + + def test_planifier_exclut_la_station_non_due(self): + rs = {"lente": r(t(12, 0), 600, frequence_s=3600), "libre": r(t(12, 0), 600)} + genre, cibles = ic.planifier({}, rs, t(12, 14)) + self.assertEqual((genre, cibles), ("principal", ["libre"])) + + +class FauxServeur: + """Stations qui publient toutes les `pas` minutes avec 2 min de retard ; compte les requêtes et stations.""" + + def __init__(self, pas=10): + self.pas, self.maintenant = pas, None + self.requetes, self.stations_demandees = 0, 0 + + def __call__(self, url): + q = urllib.parse.parse_qs(urllib.parse.urlparse(url).query) + ids = q["stations[]"] + self.requetes += 1 + self.stations_demandees += len(ids) + debut = dt.datetime.strptime(q["start"][0], "%Y-%m-%d").replace(tzinfo=UTC) + limite = self.maintenant - dt.timedelta(minutes=2) + horaire, m = {}, debut + while m <= limite: + if m.minute % self.pas == 0: + for s in ids: + horaire.setdefault(s, []).append({"dh_utc": m.strftime("%Y-%m-%d %H:%M:%S"), "temperature": "7.0"}) + m += dt.timedelta(minutes=1) + return json.dumps({"status": "OK", "errors": [], "stations": [], "hourly": horaire}).encode() + + +def simuler_24h(frequence_min, nb_stations=3, pas_station=10, debut=None): + """Tick toutes les 5 min (hh:x4 et hh:x9) pendant 24 h, avec la vraie `passer`. -> (requêtes, stations demandées).""" + debut = debut or dt.datetime(2026, 10, 16, 0, 4, tzinfo=UTC) + stations = {} + for i in range(nb_stations): + stations["S%d" % i] = {"nom": "s", "licence": "CC BY"} + if frequence_min is not None: + stations["S%d" % i]["frequence_min"] = frequence_min + with tempfile.TemporaryDirectory() as tmp: + cfg, journal = config(tmp) + st = Stockage(Path(tmp) / "m.sqlite") + srv = FauxServeur(pas_station) + try: + for k in range(24 * 12): + srv.maintenant = debut + dt.timedelta(minutes=5 * k) + ic.passer(cfg, st, journal, srv.maintenant, stations, fetch=srv) + finally: + st.fermer() + return srv.requetes, srv.stations_demandees + + +class TestSimulation24h(unittest.TestCase): + resultats = {} + + @classmethod + def setUpClass(cls): + for f in (None, 10, 30, 60): + cls.resultats[f] = simuler_24h(f) + base = cls.resultats[None][0] + print("\n[simulation 24 h, 3 stations qui publient toutes les 10 min, 288 ticks de 5 min]") + for f, (req, sta) in cls.resultats.items(): + print(" frequence_min=%-5s -> %3d requêtes, %3d demandes de station%s" % ( + f if f else "absent", req, sta, + "" if f is None else " (gain %d requêtes, %.0f %%)" % (base - req, 100 * (base - req) / base))) + + def test_sans_champ_identique_au_comportement_actuel(self): + self.assertEqual(self.resultats[None][0], 144) # même valeur que test_ordonnanceur (144/24 h) + + def test_10_min_egale_la_station(self): + self.assertEqual(self.resultats[10], self.resultats[None]) + + def test_30_et_60_min_reduisent_les_requetes(self): + self.assertLess(self.resultats[30][0], self.resultats[10][0]) + self.assertLess(self.resultats[60][0], self.resultats[30][0]) + + def test_ordre_de_grandeur(self): + # ~1 requête par période + le premier passage ; marge pour le démarrage et les dérives de 5 min + self.assertTrue(24 * 60 // 30 <= self.resultats[30][0] <= 24 * 60 // 30 + 3) + self.assertTrue(24 * 60 // 60 <= self.resultats[60][0] <= 24 * 60 // 60 + 3) + + def test_frequence_5_ne_depasse_pas_le_rythme_de_la_station(self): + self.assertEqual(simuler_24h(5)[0], self.resultats[None][0]) + + def test_station_lente_30_min_avec_reglage_10(self): + lent = simuler_24h(10, pas_station=30)[0] + self.assertEqual(lent, simuler_24h(None, pas_station=30)[0]) + + +if __name__ == "__main__": + unittest.main()