351 lignes
15 KiB
Python
351 lignes
15 KiB
Python
#!/usr/bin/env python3
|
||
"""Collecte ROMMA (api_export.php, type=live) -> JSON public filtré (public/data/romma.json).
|
||
|
||
Stations autorisées par ROMMA (accord du 24/10/2026 : « une requête toutes les 10 minutes convient », pas
|
||
d'historique via l'API, ROMMA cité) : Engins (139), Die (159), Saint-Julien-en-Quint (158), Cirque d'Archiane (212).
|
||
|
||
Un SEUL appel par passage (global=1 renvoie toutes les stations de la clé, on ne garde que les 4).
|
||
Garde-fou : jamais plus d'un appel par 10 minutes (horodatage « pas_avant_utc » écrit AVANT l'appel).
|
||
Même format que meteofrance.json / infoclimat.json. ROMMA ne donne que le relevé courant : on accumule
|
||
nos propres passages sur 24 h (pas d'historique demandé à ROMMA). Erreur : relevés précédents gardés.
|
||
|
||
Mode SIMULATION par défaut (aucun réseau, données factices, n'écrit que si --sortie est donné).
|
||
Mode --reel : exige ROMMA_APPEL_RESEAU_VALIDE=oui, ROMMA_CLE, ROMMA_URL_API (avec le marqueur {cle}) ;
|
||
variables d'environnement, sinon fichier ~/.config/meteo-vercors/romma.env (NOM=valeur). La clé n'est jamais
|
||
affichée, ni écrite ailleurs.
|
||
|
||
Usage :
|
||
python collecter_romma.py --sortie /tmp/essai.json # simulation
|
||
python collecter_romma.py --reel # un appel réel (si le délai de 10 min est passé)
|
||
"""
|
||
import argparse
|
||
import datetime as dt
|
||
import json
|
||
import os
|
||
import re
|
||
import sys
|
||
import urllib.error
|
||
import urllib.request
|
||
|
||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||
from collecter_weatherlink import CHAMPS_PUBLICS, charger_json, ecrire_atomique, fmt_utc, maintenant, verifier_public # noqa: E402
|
||
|
||
UTC = dt.timezone.utc
|
||
SOURCE_ROMMA = "ROMMA"
|
||
MENTION = "Source des données : ROMMA (Réseau d'Observation Météo du Massif Alpin) - www.romma.fr"
|
||
UA = "vercors.me/0.1 (meteo-vercors)"
|
||
RACINE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
SORTIE_DEFAUT = os.path.join(RACINE, "public", "data", "romma.json")
|
||
ENV_DEFAUT = "~/.config/meteo-vercors/romma.env"
|
||
ETAT_DEFAUT = "~/.config/meteo-vercors/romma_etat.json"
|
||
INTERVALLE_S = 600 # plancher entre deux appels
|
||
PAUSE_CLE_REFUSEE_S = 3600
|
||
HORS_LIGNE_MIN = 40
|
||
# id du site -> (numéro ROMMA, nom). Les numéros sont ceux de l'autorisation ; rien d'autre n'est conservé.
|
||
STATIONS = {
|
||
"engins": (139, "Engins"),
|
||
"die": (159, "Die"),
|
||
"st-julien-q": (158, "Saint-Julien-en-Quint"),
|
||
"archiane": (212, "Cirque d'Archiane"),
|
||
}
|
||
# [À VÉRIFIER auprès de ROMMA] unité du vent : on suppose des km/h. Si m/s, mettre 3.6.
|
||
FACTEUR_VENT = 1.0
|
||
ROSE = {n: i * 22.5 for i, n in enumerate("N NNE NE ENE E ESE SE SSE S SSO SO OSO O ONO NO NNO".split())}
|
||
|
||
|
||
class ErreurRomma(Exception):
|
||
pass
|
||
|
||
|
||
class CleRefusee(ErreurRomma):
|
||
pass
|
||
|
||
|
||
# ------------------------------------------------------------------ heure de Paris (sans tzdata)
|
||
def _dernier_dimanche(annee, mois):
|
||
d = dt.date(annee, mois, 31)
|
||
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
|
||
|
||
|
||
def paris_vers_utc(local):
|
||
"""datetime naïf (heure de Paris) -> UTC. None si l'heure n'existe pas (saut de mars)."""
|
||
debut = dt.datetime.combine(_dernier_dimanche(local.year, 3), dt.time(1), UTC)
|
||
fin = dt.datetime.combine(_dernier_dimanche(local.year, 10), dt.time(1), UTC)
|
||
ete = (local - dt.timedelta(hours=2)).replace(tzinfo=UTC)
|
||
if debut <= ete < fin:
|
||
return ete
|
||
hiver = (local - dt.timedelta(hours=1)).replace(tzinfo=UTC)
|
||
return hiver if (hiver < debut or hiver >= fin) else None
|
||
|
||
|
||
# ------------------------------------------------------------------ clé et réglages
|
||
def lire_env(fichier):
|
||
"""Lit NOM=valeur du fichier (si présent), puis l'environnement l'emporte. Rien n'est affiché."""
|
||
out = {}
|
||
try:
|
||
with open(os.path.expanduser(fichier), encoding="utf-8") as f:
|
||
for ligne in f:
|
||
nom, sep, val = ligne.strip().partition("=")
|
||
if sep and not nom.startswith("#"):
|
||
out[nom.strip()] = val.strip().strip('"').strip("'")
|
||
except OSError:
|
||
pass
|
||
for nom in ("ROMMA_CLE", "ROMMA_URL_API", "ROMMA_APPEL_RESEAU_VALIDE"):
|
||
if os.environ.get(nom):
|
||
out[nom] = os.environ[nom]
|
||
return out
|
||
|
||
|
||
def masquer(t, cle):
|
||
return t.replace(cle, "***") if cle else t
|
||
|
||
|
||
def appeler(url_modele, cle, ouvrir=None):
|
||
"""UN appel. La clé n'apparaît dans aucun message d'erreur."""
|
||
req = urllib.request.Request(url_modele.replace("{cle}", cle), headers={"User-Agent": UA, "Accept": "application/json"})
|
||
try:
|
||
with (ouvrir or urllib.request.urlopen)(req, timeout=30) as r:
|
||
return r.read()
|
||
except urllib.error.HTTPError as e:
|
||
raise ErreurRomma("HTTP %d" % e.code)
|
||
except Exception as e:
|
||
raise ErreurRomma("réseau : %s" % type(e).__name__)
|
||
|
||
|
||
# ------------------------------------------------------------------ lecture de la réponse
|
||
def nombre(o, cle):
|
||
v = o.get(cle)
|
||
if isinstance(v, bool) or v is None:
|
||
return None
|
||
if isinstance(v, (int, float)):
|
||
return float(v)
|
||
if isinstance(v, str):
|
||
s = v.strip()
|
||
if not s or s.upper() == "NULL":
|
||
return None
|
||
try:
|
||
return float(s.replace(",", "."))
|
||
except ValueError:
|
||
return None
|
||
return None
|
||
|
||
|
||
def texte(o, cle):
|
||
v = o.get(cle)
|
||
if isinstance(v, (int, float)) and not isinstance(v, bool):
|
||
return str(int(v)) if float(v).is_integer() else str(v)
|
||
if isinstance(v, str) and v.strip() and v.strip().upper() != "NULL":
|
||
return v.strip()
|
||
return None
|
||
|
||
|
||
def lire_date_heure(date, heure):
|
||
m = re.fullmatch(r"\s*(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})\s*", date or "")
|
||
h = re.fullmatch(r"\s*(\d{1,2}):(\d{2})(?::(\d{2}))?\s*", heure or "")
|
||
if not m or not h:
|
||
return None
|
||
a = int(m.group(3))
|
||
try:
|
||
return dt.datetime(a + 2000 if a < 100 else a, int(m.group(2)), int(m.group(1)),
|
||
int(h.group(1)), int(h.group(2)), int(h.group(3) or 0))
|
||
except ValueError:
|
||
return None
|
||
|
||
|
||
def parser_reponse(corps, fin, cle=""):
|
||
"""Réponse brute -> ({id_site: (relevé public, métadonnées)}, avertissements). Lève ErreurRomma / CleRefusee.
|
||
Ne garde que les 4 stations autorisées ; ignore les mesures invalides, sans température ou dans le futur."""
|
||
if isinstance(corps, bytes):
|
||
corps = corps.decode("utf-8", errors="replace")
|
||
try:
|
||
valeur = json.loads(corps.strip().lstrip(""))
|
||
except ValueError:
|
||
raise ErreurRomma("réponse non JSON")
|
||
if isinstance(valeur, str):
|
||
bas = valeur.lower()
|
||
if "apikey invalid" in bas or "no user associated" in bas:
|
||
raise CleRefusee("clé refusée")
|
||
raise ErreurRomma(masquer(valeur, cle)[:120])
|
||
if not isinstance(valeur, list):
|
||
raise ErreurRomma("tableau de stations attendu")
|
||
par_numero = {str(n): sid for sid, (n, _) in STATIONS.items()}
|
||
out, avert = {}, []
|
||
for o in valeur:
|
||
sid = par_numero.get(texte(o, "id_station") or "") if isinstance(o, dict) else None
|
||
if not sid:
|
||
continue # station hors autorisation : jamais conservée
|
||
if not (nombre(o, "is_valide") or 0):
|
||
avert.append("%s : is_valide=0" % sid)
|
||
continue
|
||
loc = lire_date_heure(texte(o, "date"), texte(o, "heure"))
|
||
d = paris_vers_utc(loc) if loc else None
|
||
if d is None:
|
||
avert.append("%s : date/heure inutilisable" % sid)
|
||
continue
|
||
if (d - fin).total_seconds() > 900:
|
||
avert.append("%s : mesure dans le futur" % sid)
|
||
continue
|
||
t = nombre(o, "temperature")
|
||
if t is None:
|
||
avert.append("%s : pas de température" % sid)
|
||
continue
|
||
r = {"dh_utc": fmt_utc(d), "temperature": round(t, 1)}
|
||
h, p = nombre(o, "humidite"), nombre(o, "pression")
|
||
v, raf = nombre(o, "vent_moyen_10min"), nombre(o, "vent_rafale_maxi_10min")
|
||
deg = nombre(o, "vent_direction_degres")
|
||
if deg is None:
|
||
deg = ROSE.get((texte(o, "vent_direction") or "").upper())
|
||
pj = nombre(o, "pluie_jour")
|
||
if h is not None:
|
||
r["humidite"] = int(round(h))
|
||
if p is not None:
|
||
r["pression"] = round(p, 1)
|
||
if v is not None:
|
||
r["vent_moyen"] = round(v * FACTEUR_VENT, 1)
|
||
if raf is not None:
|
||
r["vent_rafales"] = round(raf * FACTEUR_VENT, 1)
|
||
if deg is not None and v:
|
||
r["vent_direction"] = int(round(deg)) % 360
|
||
if pj is not None:
|
||
r["pluie_cumul_0h"] = round(pj, 1)
|
||
meta = {"licence": SOURCE_ROMMA}
|
||
lat, lon, alt = nombre(o, "latitude"), nombre(o, "longitude"), nombre(o, "altitude")
|
||
if lat is not None and lon is not None:
|
||
meta["lat"], meta["lon"] = round(lat, 2), round(lon, 2)
|
||
if alt is not None:
|
||
meta["altitude"] = int(round(alt))
|
||
out[sid] = (r, meta)
|
||
return out, avert
|
||
|
||
|
||
# ------------------------------------------------------------------ assemblage
|
||
def lire_dh(s):
|
||
return dt.datetime.strptime(s[:19].replace("T", " "), "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
|
||
|
||
|
||
def construire(precedent, nouveaux, fin, heures=24):
|
||
"""Ancien JSON + relevés du passage -> (nouveau JSON, journal). Sans nouveauté, la station garde ses relevés."""
|
||
anciens = (precedent or {}).get("stations") or {}
|
||
metas = dict((precedent or {}).get("metadonnees") or {})
|
||
debut = fin - dt.timedelta(hours=heures)
|
||
stations, journal = {}, []
|
||
for sid, (_, nom) in STATIONS.items():
|
||
par_date = {}
|
||
for r in (anciens.get(sid) or {}).get("releves") or []:
|
||
if isinstance(r, dict) and isinstance(r.get("dh_utc"), str):
|
||
par_date[r["dh_utc"]] = {k: r[k] for k in CHAMPS_PUBLICS
|
||
if k in r and k not in ("temperature_min", "temperature_max")}
|
||
if sid in nouveaux:
|
||
r, meta = nouveaux[sid]
|
||
par_date[r["dh_utc"]] = r
|
||
metas[sid] = {**metas.get(sid, {}), **meta}
|
||
metas.setdefault(sid, {"licence": SOURCE_ROMMA})
|
||
rel = [par_date[d] for d in sorted(par_date) if lire_dh(d) > debut]
|
||
if rel:
|
||
ts = [r["temperature"] for r in rel]
|
||
rel[-1]["temperature_min"], rel[-1]["temperature_max"] = min(ts), max(ts)
|
||
hors = not rel or fin - lire_dh(rel[-1]["dh_utc"]) > dt.timedelta(minutes=HORS_LIGNE_MIN)
|
||
stations[sid] = {"nom": nom, "source": SOURCE_ROMMA, "hors_ligne": hors, "releves": rel}
|
||
journal.append("%s: %s (%d relevés)" % (sid, "nouveau" if sid in nouveaux else "pas de nouveau", len(rel)))
|
||
obj = {"source": MENTION, "mis_a_jour_utc": fin.strftime("%Y-%m-%dT%H:%M:%SZ"),
|
||
"metadonnees": {sid: metas[sid] for sid in STATIONS}, "stations": stations}
|
||
return obj, journal
|
||
|
||
|
||
# ------------------------------------------------------------------ garde-fou 10 minutes
|
||
def reserver_passage(etat_chemin, fin, secondes=INTERVALLE_S):
|
||
"""(True, None) si un appel est permis ; écrit alors « pas_avant_utc » AVANT l'appel (un plantage ne le rejoue pas)."""
|
||
etat = charger_json(etat_chemin) if etat_chemin else {}
|
||
jusque = etat.get("pas_avant_utc")
|
||
if jusque:
|
||
try:
|
||
if fin < lire_dh(jusque):
|
||
return False, jusque
|
||
except ValueError:
|
||
pass
|
||
if etat_chemin:
|
||
etat["pas_avant_utc"] = fmt_utc(fin + dt.timedelta(seconds=secondes))
|
||
ecrire_atomique(etat_chemin, etat)
|
||
return True, None
|
||
|
||
|
||
def repousser(etat_chemin, fin, secondes, message):
|
||
if etat_chemin:
|
||
etat = charger_json(etat_chemin)
|
||
etat["pas_avant_utc"] = fmt_utc(fin + dt.timedelta(seconds=secondes))
|
||
etat["derniere_erreur"] = message[:120]
|
||
ecrire_atomique(etat_chemin, etat)
|
||
|
||
|
||
# ------------------------------------------------------------------ simulation
|
||
def reponse_factice(fin):
|
||
loc = (fin + dt.timedelta(hours=1)).replace(tzinfo=None) # simulation seulement : heure d'hiver
|
||
out = []
|
||
for i, (sid, (num, nom)) in enumerate(STATIONS.items()):
|
||
out.append({"id_station": num, "station": nom, "altitude": 500 + 100 * i, "latitude": 44.8 + i / 10,
|
||
"longitude": 5.4, "is_valide": 1, "date": loc.strftime("%d/%m/%y"), "heure": loc.strftime("%H:%M"),
|
||
"temperature": 7.5 + i, "pression": 1012.3, "humidite": "NULL", "radiation": "NULL",
|
||
"vent_moyen_10min": 12 + i, "vent_rafale_maxi_10min": 30, "vent_direction": "SSO",
|
||
"vent_direction_degres": 202, "pluie_jour": "0.4", "neige": "NULL"})
|
||
out.append({"id_station": 4, "station": "Hors autorisation", "is_valide": 1, "temperature": 3,
|
||
"date": loc.strftime("%d/%m/%y"), "heure": loc.strftime("%H:%M")})
|
||
return json.dumps(out).encode()
|
||
|
||
|
||
# ------------------------------------------------------------------ programme
|
||
def passage(precedent, fetch, fin, cle="", etat_chemin=None):
|
||
"""Un passage complet. fetch() -> corps brut. -> (objet à écrire ou None, message, code).
|
||
Erreur : relevés précédents gardés (objet reconstruit sans nouveauté)."""
|
||
ok, jusque = reserver_passage(etat_chemin, fin)
|
||
if not ok:
|
||
return None, "attente : prochain appel permis après %s UTC" % jusque, 0
|
||
try:
|
||
nouveaux, avert = parser_reponse(fetch(), fin, cle)
|
||
except ErreurRomma as e:
|
||
msg = masquer(str(e), cle)
|
||
repousser(etat_chemin, fin, PAUSE_CLE_REFUSEE_S if isinstance(e, CleRefusee) else INTERVALLE_S, msg)
|
||
if precedent:
|
||
obj, journal = construire(precedent, {}, fin)
|
||
return obj, "erreur (%s), relevés précédents gardés ; %s" % (msg, "; ".join(journal)), 0
|
||
return None, "erreur (%s), rien à garder" % msg, 1
|
||
obj, journal = construire(precedent, nouveaux, fin)
|
||
return obj, "ok ; " + "; ".join(journal + avert), 0
|
||
|
||
|
||
def main(argv=None):
|
||
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||
ap.add_argument("--reel", action="store_true", help="appel réseau réel (garde-fous requis) ; défaut : simulation")
|
||
ap.add_argument("--sortie", default=None, help="défaut en réel : public/data/romma.json ; en simulation : rien n'est écrit")
|
||
ap.add_argument("--fichier-env", default=ENV_DEFAUT)
|
||
ap.add_argument("--etat", default=None, help="fichier d'horodatage du garde-fou (défaut réel : %s)" % ETAT_DEFAUT)
|
||
a = ap.parse_args(argv)
|
||
fin = maintenant()
|
||
cle, etat = "", a.etat
|
||
if a.reel:
|
||
env = lire_env(a.fichier_env)
|
||
cle, url = env.get("ROMMA_CLE", ""), env.get("ROMMA_URL_API", "")
|
||
if env.get("ROMMA_APPEL_RESEAU_VALIDE") != "oui":
|
||
print("refusé : ROMMA_APPEL_RESEAU_VALIDE=oui non déclaré (validation de Théo)")
|
||
return 2
|
||
if not cle or "{cle}" not in url:
|
||
print("refusé : ROMMA_CLE et ROMMA_URL_API (avec {cle}) requises dans %s" % a.fichier_env)
|
||
return 2
|
||
sortie = a.sortie or SORTIE_DEFAUT
|
||
etat = etat or os.path.expanduser(ETAT_DEFAUT)
|
||
fetch = lambda: appeler(url, cle) # noqa: E731
|
||
else:
|
||
sortie = a.sortie
|
||
fetch = lambda: reponse_factice(fin) # noqa: E731
|
||
precedent = charger_json(sortie) if sortie else {}
|
||
obj, msg, code = passage(precedent, fetch, fin, cle, etat)
|
||
if obj is not None:
|
||
verifier_public(obj)
|
||
if sortie:
|
||
ecrire_atomique(sortie, obj)
|
||
print(("" if a.reel else "[simulation] ") + msg)
|
||
return code
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|