Auteur SHA1 Message Date

2026-10-18

Théo GastineletClaude Sonnet 5.5 4dab8c7388 Infoclimat : frequence_min par station (dashboard meteo-lan)
Une station qui porte frequence_min (5 a 1440, export meteo-lan) n'est due
qu'apres max(frequence_min, rythme mesure) + delai de publication depuis sa
derniere mesure. Sans le champ : comportement inchange. Valeur invalide
(non entier, bool, hors 5-1440) : ignoree, une ligne de journal.

Tests hors ligne : validation, regle de due, simulation 24 h (vraie passer,
faux serveur) : 144 requetes sans champ ou a 10 min, 48 a 30 min, 24 a 60 min.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-18 21:10:26 +02:00
2 fichiers modifiés avec 191 ajouts et 3 suppressions

Aucun fichier ne correspond à votre recherche

+29 -3
Voir le fichier
@@ -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:
+162
Voir le fichier
@@ -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()