Collecteur ROMMA direct (Engins, Die, Saint-Julien-en-Quint, Archiane) : un appel par passage, garde-fou de 10 min, simulation par défaut
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
2dfe5dada7
révision
518abc0708
3 fichiers modifiés
+547
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,350 @@
|
||||
#!/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())
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/bin/bash
|
||||
# Enregistre la clé ROMMA sans l'afficher, dans ~/.config/meteo-vercors/romma.env (droits 600).
|
||||
# Usage : bash poser_cle_romma.sh
|
||||
# Ne pose PAS ROMMA_APPEL_RESEAU_VALIDE : c'est à Théo de le déclarer, à la main, le jour du premier appel réel.
|
||||
set -eu
|
||||
f=~/.config/meteo-vercors/romma.env
|
||||
mkdir -p "$(dirname "$f")"
|
||||
read -rsp "Colle la clé ROMMA puis Entrée : " K; echo
|
||||
[ -n "$K" ] || { echo "Clé vide : rien n'a changé."; exit 1; }
|
||||
# URL de l'API, avec {cle} à la place de la clé (jamais la clé elle-même). Entrée vide = valeur actuelle,
|
||||
# sinon celle relevée dans le code de GWS (non documentée publiquement, à confirmer auprès de ROMMA).
|
||||
defaut='https://www.romma.fr/api_export.php/?apikey={cle}&type=live&global=1'
|
||||
actuelle="$(grep '^ROMMA_URL_API=' "$f" 2>/dev/null | cut -d= -f2- || true)"
|
||||
echo "URL actuelle : ${actuelle:-(aucune)}"
|
||||
read -rp "URL avec {cle} [Entrée = ${actuelle:-$defaut}] : " U
|
||||
U="${U:-${actuelle:-$defaut}}"
|
||||
case "$U" in *'{cle}'*) ;; *) echo "L'URL doit contenir {cle} : rien n'a changé."; exit 1;; esac
|
||||
umask 077
|
||||
touch "$f"
|
||||
{ grep -v -e '^ROMMA_CLE=' -e '^ROMMA_URL_API=' "$f" || true; } > "$f.tmp"
|
||||
printf 'ROMMA_CLE=%s\nROMMA_URL_API=%s\n' "$K" "$U" >> "$f.tmp"
|
||||
mv "$f.tmp" "$f"
|
||||
chmod 600 "$f"
|
||||
echo "ok : ROMMA_CLE enregistrée (${#K} caractères) et ROMMA_URL_API dans $f"
|
||||
echo "Étape suivante (à toi, après ton feu vert) : ajouter la ligne ROMMA_APPEL_RESEAU_VALIDE=oui dans ce fichier, puis"
|
||||
echo " python3 collecter_romma.py --reel # UN appel ; un 2e lancement avant 10 min est refusé par le garde-fou"
|
||||
@@ -0,0 +1,171 @@
|
||||
"""Tests du collecteur ROMMA, sans réseau : python -m unittest discover -s tests"""
|
||||
import contextlib
|
||||
import datetime as dt
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import collecter_romma as cr # noqa: E402
|
||||
from collecter_weatherlink import verifier_public # noqa: E402
|
||||
|
||||
FIN = dt.datetime(2026, 11, 5, 10, 0, tzinfo=dt.timezone.utc) # 11:00 à Paris (hiver)
|
||||
CLE = "CLE-SECRETE-XYZ"
|
||||
|
||||
|
||||
def ligne(num, heure="10:55", **kw):
|
||||
o = {"id_station": num, "station": "S%s" % num, "altitude": 1000, "latitude": 44.91, "longitude": 5.43,
|
||||
"is_valide": 1, "date": "05/11/26", "heure": heure, "temperature": "5,5", "pression": 1010,
|
||||
"humidite": "NULL", "vent_moyen_10min": 10, "vent_rafale_maxi_10min": 25, "vent_direction": "SSO",
|
||||
"vent_direction_degres": 200, "pluie_jour": "1.2"}
|
||||
o.update(kw)
|
||||
return o
|
||||
|
||||
|
||||
def corps(*lignes):
|
||||
return json.dumps(list(lignes)).encode()
|
||||
|
||||
|
||||
class TestRomma(unittest.TestCase):
|
||||
def test_parse_filtre_et_unites(self):
|
||||
r, _ = cr.parser_reponse(corps(ligne(139), ligne(4), ligne(159, humidite="80")), FIN)
|
||||
self.assertEqual(set(r), {"engins", "die"}) # station 4 hors autorisation
|
||||
rel = r["engins"][0]
|
||||
self.assertEqual(rel["dh_utc"], "2026-11-05 09:55:00")
|
||||
self.assertEqual((rel["temperature"], rel["vent_moyen"], rel["vent_direction"], rel["pluie_cumul_0h"]),
|
||||
(5.5, 10.0, 200, 1.2))
|
||||
self.assertNotIn("humidite", rel)
|
||||
self.assertEqual(r["die"][0]["humidite"], 80)
|
||||
self.assertEqual(r["engins"][1]["lat"], 44.91)
|
||||
|
||||
def test_ignores(self):
|
||||
r, av = cr.parser_reponse(corps(ligne(139, is_valide=0), ligne(159, temperature="NULL"),
|
||||
ligne(158, heure="12:30"), ligne(212, date="xx")), FIN)
|
||||
self.assertEqual(r, {})
|
||||
self.assertEqual(len(av), 4)
|
||||
|
||||
def test_cle_refusee_et_reponse_invalide(self):
|
||||
with self.assertRaises(cr.CleRefusee):
|
||||
cr.parser_reponse(json.dumps("Erreur : no user associated or apikey invalid"), FIN)
|
||||
with self.assertRaises(cr.ErreurRomma):
|
||||
cr.parser_reponse("<html>", FIN)
|
||||
|
||||
def test_sortie_publique(self):
|
||||
r, _ = cr.parser_reponse(cr.reponse_factice(FIN), FIN)
|
||||
obj, _ = cr.construire({}, r, FIN)
|
||||
verifier_public(obj)
|
||||
self.assertEqual(set(obj["stations"]), set(cr.STATIONS))
|
||||
self.assertEqual(obj["stations"]["die"]["source"], "ROMMA")
|
||||
self.assertFalse(obj["stations"]["die"]["hors_ligne"])
|
||||
self.assertNotIn("Hors autorisation", json.dumps(obj))
|
||||
|
||||
def test_accumulation_et_fenetre(self):
|
||||
prec, _ = cr.construire({}, cr.parser_reponse(corps(ligne(139, heure="10:50", temperature=2)), FIN)[0], FIN)
|
||||
r2, _ = cr.parser_reponse(corps(ligne(139, heure="10:55", temperature=8)), FIN)
|
||||
obj, _ = cr.construire(prec, r2, FIN)
|
||||
rel = obj["stations"]["engins"]["releves"]
|
||||
self.assertEqual(len(rel), 2)
|
||||
self.assertEqual((rel[-1]["temperature_min"], rel[-1]["temperature_max"]), (2.0, 8.0))
|
||||
obj2, _ = cr.construire(obj, {}, FIN + dt.timedelta(hours=25)) # hors fenêtre de 24 h
|
||||
self.assertEqual(obj2["stations"]["engins"]["releves"], [])
|
||||
self.assertTrue(obj2["stations"]["engins"]["hors_ligne"])
|
||||
|
||||
def test_erreur_garde_precedent(self):
|
||||
prec, _ = cr.construire({}, cr.parser_reponse(cr.reponse_factice(FIN), FIN)[0], FIN)
|
||||
|
||||
def casse():
|
||||
raise cr.ErreurRomma("HTTP 500")
|
||||
obj, msg, code = cr.passage(prec, casse, FIN + dt.timedelta(minutes=5), CLE, None)
|
||||
self.assertEqual(code, 0)
|
||||
self.assertEqual(len(obj["stations"]["die"]["releves"]), 1)
|
||||
self.assertIn("précédents gardés", msg)
|
||||
obj, msg, code = cr.passage({}, casse, FIN, CLE, None)
|
||||
self.assertEqual((obj, code), (None, 1))
|
||||
|
||||
def test_garde_fou_10_minutes(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
etat = os.path.join(d, "etat.json")
|
||||
appels = []
|
||||
|
||||
def f():
|
||||
appels.append(1)
|
||||
return cr.reponse_factice(FIN)
|
||||
self.assertIsNotNone(cr.passage({}, f, FIN, CLE, etat)[0])
|
||||
obj, msg, _ = cr.passage({}, f, FIN + dt.timedelta(minutes=9), CLE, etat)
|
||||
self.assertIsNone(obj)
|
||||
self.assertIn("attente", msg)
|
||||
self.assertEqual(len(appels), 1) # un seul appel pour les 4 stations
|
||||
cr.passage({}, f, FIN + dt.timedelta(minutes=10, seconds=1), CLE, etat)
|
||||
self.assertEqual(len(appels), 2)
|
||||
|
||||
def test_garde_fou_apres_erreur_et_cle_refusee(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
etat = os.path.join(d, "etat.json")
|
||||
|
||||
def refuse():
|
||||
raise cr.CleRefusee("clé refusée")
|
||||
cr.passage({}, refuse, FIN, CLE, etat)
|
||||
obj, msg, _ = cr.passage({}, refuse, FIN + dt.timedelta(minutes=30), CLE, etat)
|
||||
self.assertIsNone(obj)
|
||||
self.assertIn("attente", msg) # clé refusée : pause d'une heure
|
||||
|
||||
def test_main_refuse_sans_validation_et_n_affiche_pas_la_cle(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
env = os.path.join(d, "romma.env")
|
||||
with open(env, "w") as f:
|
||||
f.write("ROMMA_CLE=%s\nROMMA_URL_API=https://exemple.invalide/?k={cle}\n" % CLE)
|
||||
for k in ("ROMMA_CLE", "ROMMA_URL_API", "ROMMA_APPEL_RESEAU_VALIDE"):
|
||||
os.environ.pop(k, None)
|
||||
sortie = io.StringIO()
|
||||
with contextlib.redirect_stdout(sortie):
|
||||
code = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
|
||||
"--etat", os.path.join(d, "e.json")])
|
||||
self.assertEqual(code, 2) # validation absente : aucun appel
|
||||
self.assertNotIn(CLE, sortie.getvalue())
|
||||
self.assertFalse(os.path.exists(os.path.join(d, "r.json")))
|
||||
|
||||
def test_main_reel_erreur_reseau_masque_la_cle(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
env = os.path.join(d, "romma.env")
|
||||
with open(env, "w") as f:
|
||||
f.write("ROMMA_CLE=%s\nROMMA_URL_API=https://exemple.invalide/?k={cle}\n"
|
||||
"ROMMA_APPEL_RESEAU_VALIDE=oui\n" % CLE)
|
||||
appels = []
|
||||
|
||||
def ouvrir(req, timeout=0):
|
||||
appels.append(req.full_url)
|
||||
raise OSError("échec " + req.full_url)
|
||||
vrai = cr.urllib.request.urlopen
|
||||
cr.urllib.request.urlopen = ouvrir
|
||||
try:
|
||||
sortie = io.StringIO()
|
||||
with contextlib.redirect_stdout(sortie):
|
||||
code = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
|
||||
"--etat", os.path.join(d, "e.json")])
|
||||
code2 = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
|
||||
"--etat", os.path.join(d, "e.json")])
|
||||
finally:
|
||||
cr.urllib.request.urlopen = vrai
|
||||
self.assertEqual((code, code2), (1, 0))
|
||||
self.assertEqual(len(appels), 1) # le 2e passage est bloqué par le garde-fou
|
||||
self.assertNotIn(CLE, sortie.getvalue())
|
||||
|
||||
def test_simulation_par_defaut(self):
|
||||
with contextlib.redirect_stdout(io.StringIO()) as s:
|
||||
self.assertEqual(cr.main([]), 0) # sans --sortie : rien n'est écrit
|
||||
self.assertIn("[simulation]", s.getvalue())
|
||||
|
||||
def test_lire_env(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
env = os.path.join(d, "e")
|
||||
with open(env, "w") as f:
|
||||
f.write("# c\nROMMA_CLE=\"abc\"\n")
|
||||
os.environ.pop("ROMMA_CLE", None)
|
||||
self.assertEqual(cr.lire_env(env)["ROMMA_CLE"], "abc")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur