diff --git a/meteo_collecte/publier.py b/meteo_collecte/publier.py new file mode 100644 index 0000000..bac897f --- /dev/null +++ b/meteo_collecte/publier.py @@ -0,0 +1,96 @@ +"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous /data/. + +* data/stations.json : index de toutes les stations avec leur dernière mesure ; +* data/station/-.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ; +* data/etat.json : heure de mise à jour par source, sources en pause. + +Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage +(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers. +Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API. +""" +import datetime as dt +import re + +from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc +from .stockage import CHAMPS + +ATTRIBUTIONS = { + "infoclimat": "Données Infoclimat", + "romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur " + "interprétation.", + "meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)", +} + + +def nom_fichier(source, station_id): + """Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin).""" + return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id))) + + +def _releve(r): + return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None}) + + +def _fiche(st): + return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"], + "nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"), + "licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")} + + +def publier(cfg, stockage, maintenant, resumes=None): + data = cfg.public / "data" + index = [] + depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures) + for st in stockage.stations(): + fiche = _fiche(st) + der = stockage.derniere(st["source"], st["station_id"]) + if der: + fiche["derniere"] = _releve(der) + fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60) + else: + fiche["derniere"], fiche["age_min"] = None, None + index.append(fiche) + serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)] + ecrire_json(data / "station" / (fiche["id"] + ".json"), + dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie)) + ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index}) + ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {})) + if cfg.direct_compat: + publier_direct_compat(cfg, stockage, maintenant) + return len(index) + + +def etat(cfg, maintenant, resumes): + from .commun import Pause, lire_json + sources = {} + for src in ("infoclimat", "romma"): + e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {}) + p = Pause(cfg.base / "var" / ("pause_%s.txt" % src)) + succes = e.get("dernier_succes_utc") + sources[src] = { + "dernier_succes_utc": iso(lire_utc(succes)) if succes else None, + "en_pause": p.active(maintenant), + "pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None, + "dernier_passage": (resumes.get(src) or {}).get("action"), + } + return {"mis_a_jour_utc": iso(maintenant), "sources": sources} + + +def publier_direct_compat(cfg, stockage, maintenant): + """Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré.""" + depuis = maintenant - dt.timedelta(hours=48) + stations, meta = {}, {} + for st in stockage.stations(): + if st["source"] != "infoclimat": + continue + rel = [] + for r in stockage.serie("infoclimat", st["station_id"], depuis): + x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression", + "vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")} + x["pluie_cumul_0h"] = r.get("pluie_cumul") + rel.append(x) + stations[st["station_id"]] = {"nom": st["nom"], "releves": rel} + meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"], + "licence": st["licence"] or ""} + ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)", + "mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations}) diff --git a/tests/test_publier.py b/tests/test_publier.py new file mode 100644 index 0000000..b1d43cb --- /dev/null +++ b/tests/test_publier.py @@ -0,0 +1,62 @@ +import tempfile +import unittest +from pathlib import Path + +from meteo_collecte import publier +from meteo_collecte.commun import lire_json +from meteo_collecte.stockage import Stockage +from tests.aide import config, t + + +class TestPublier(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.cfg, _ = config(self.tmp.name) + self.s = Stockage(Path(self.tmp.name) / "m.sqlite") + self.s.maj_station("infoclimat", "000T0", nom="Lans", licence="CC BY") + self.s.maj_station("romma", "80", nom="Lans-en-Vercors", lat=45.1, lien="https://www.romma.fr/station_24.php?id=80") + self.s.ajouter("infoclimat", "000T0", [{"dh_utc": "2026-10-14 10:00:00", "temperature": 1}, + {"dh_utc": "2026-10-16 11:50:00", "temperature": 5}], t(12, 0)) + self.s.ajouter("romma", "80", [{"dh_utc": "2026-10-16 11:50:00", "temperature": 7, "pluie_cumul": 0.2}], t(12, 0)) + self.data = self.cfg.public / "data" + + def tearDown(self): + self.s.fermer() + self.tmp.cleanup() + + def test_index_fiches_etat(self): + n = publier.publier(self.cfg, self.s, t(12, 4)) + self.assertEqual(n, 2) + idx = lire_json(self.data / "stations.json", {}) + par = {x["id"]: x for x in idx["stations"]} + self.assertEqual(par["infoclimat-000T0"]["derniere"]["temperature"], 5) + self.assertEqual(par["romma-80"]["derniere"]["temperature"], 7) # pas de mélange entre sources + self.assertEqual(par["romma-80"]["age_min"], 14) + self.assertIn("ROMMA n'est pas responsable", par["romma-80"]["attribution"]) + fiche = lire_json(self.data / "station" / "infoclimat-000T0.json", {}) + self.assertEqual(len(fiche["releves"]), 1) # 48 h seulement + etat = lire_json(self.data / "etat.json", {}) + self.assertIn("romma", etat["sources"]) + self.assertEqual(sorted(p.name for p in self.data.iterdir()), ["etat.json", "station", "stations.json"]) + + def test_aucun_secret_publie(self): + publier.publier(self.cfg, self.s, t(12, 4)) + for p in self.data.rglob("*.json"): + texte = p.read_text(encoding="utf-8") + self.assertNotIn("FICTI", texte) + self.assertNotIn("token", texte) + self.assertNotIn("apikey", texte) + + def test_nom_de_fichier_sur(self): + self.assertEqual(publier.nom_fichier("romma", "../../etc"), "romma-______etc") + + def test_direct_compat(self): + self.cfg.direct_compat = Path(self.tmp.name) / "direct.json" + publier.publier(self.cfg, self.s, t(12, 4)) + d = lire_json(self.cfg.direct_compat, {}) + self.assertEqual(list(d["stations"]), ["000T0"]) + self.assertIn("pluie_cumul_0h", d["stations"]["000T0"]["releves"][0]) + + +if __name__ == "__main__": + unittest.main()