Fichiers
meteo-vercors/collecte/collecter_romma.py
T

351 lignes
15 KiB
Python
Brut Annotations Historique

Ce fichier contient des caractères Unicode invisibles.
Ce fichier contient des caractères Unicode invisibles à l'œil nu, mais peuvent être traités différemment par un ordinateur. Si vous pensez que c'est intentionnel, vous pouvez ignorer cet avertissement. Utilisez le bouton Échappe pour les dévoiler.
#!/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())