Publication des fichiers statiques

data/stations.json, data/station/<source>-<id>.json (48 h),
data/etat.json, ecriture atomique, attribution par source, nom de
fichier assaini. direct.json de compatibilite optionnel (MC_DIRECT_COMPAT).

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:59:52 +02:00
1 Parent 35d60a46d6
révision b3c8d0a929
2 fichiers modifiés
+158

Aucun fichier ne correspond à votre recherche

+96
Voir le fichier
@@ -0,0 +1,96 @@
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
* data/stations.json : index de toutes les stations avec leur dernière mesure ;
* data/station/<source>-<id>.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})
+62
Voir le fichier
@@ -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()