Comparer les révisions
1
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
4dab8c7388 | |||
Aucun fichier ne correspond à votre recherche
@@ -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:
|
||||
|
||||
@@ -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()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur