Module ROMMA (API live, global=1)

Logique reprise de romma_api.rs : "NULL" texte, heure de Paris vers
UTC, erreur de cle en chaine JSON avec HTTP 200, is_valide, pluie_jour
range comme cumul, cle masquee. Un appel au plus toutes les 10 min,
pause 15 min sur erreur, aucun appel sans cle. Tests hors ligne.

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:18 +02:00
1 Parent 017dfd9728
révision 35d60a46d6
4 fichiers modifiés
+407

Aucun fichier ne correspond à votre recherche

+229
Voir le fichier
@@ -0,0 +1,229 @@
"""Source ROMMA, API « live » : logique reprise de romma_api.rs (GastinelWeatherStudio, branche romma-api).
GET https://www.romma.fr/api_export.php/?apikey=<CLE>&type=live&global=1
Particularités de la réponse (vérifiées le 14/10/2026 côté GWS) :
* un tableau JSON, un objet par station ; une valeur absente est la *chaîne* "NULL" ;
* date et heure en heure locale de Paris ("14/10/26", "23:50") -> converties en UTC ;
* une clé refusée arrive en HTTP 200 sous forme de chaîne JSON "Erreur : no user associated or apikey invalid",
un type inconnu donne "Type error" ;
* is_valide = 0 (ou absent) -> mesure non enregistrée ;
* pluie_jour est un cumul depuis minuit : rangé dans `pluie_cumul`, jamais dans `pluie_1h`.
Une requête (global=1) toutes les 10 min au plus, quel que soit le nombre de stations (décision du 16/10).
La clé est lue au moment de l'appel et masquée dans tout message.
"""
import datetime as dt
import json
import re
import urllib.parse
import urllib.request
from .commun import UTC, Pause, ecrire_json, fmt_utc, jour_paris, lire_json, lire_secret, paris_vers_utc, scrub
SOURCE = "romma"
URL_BASE = "https://www.romma.fr/api_export.php/"
PAGE_STATION = "https://www.romma.fr/station_24.php?id="
UA = "weather.gastinel.me/0.1 (meteo-collecte)"
INTERVALLE_MIN_S = 10 * 60
AVANCE_TOLEREE_S = 15 * 60
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())}
ROSE.update({k.replace("O", "W"): v for k, v in list(ROSE.items()) if "O" in k})
class ErreurRomma(Exception):
pass
class CleRefusee(ErreurRomma):
pass
def construire_url(cle):
return URL_BASE + "?apikey=%s&type=live&global=1" % urllib.parse.quote(cle, safe="")
def page_station(id_station):
"""Lien public seulement pour un identifiant entier : on ne fabrique jamais d'URL depuis un texte libre."""
s = str(id_station).strip()
return PAGE_STATION + s if s.isdigit() else None
def nombre(obj, cle):
v = obj.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(obj, cle):
v = obj.get(cle)
if isinstance(v, str):
s = v.strip()
return None if not s or s.upper() == "NULL" else s
if isinstance(v, (int, float)) and not isinstance(v, bool):
return str(v)
return None
def lire_date_heure(date, heure):
""""14/10/26" + "23:50" -> datetime naïf (heure de Paris). Année sur 2 ou 4 chiffres."""
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))
a = a + 2000 if a < 100 else a
try:
return dt.datetime(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 _erreur_texte(message, cle):
bas = message.lower()
if "no user associated" in bas or "apikey invalid" in bas:
return CleRefusee("clé ROMMA refusée")
if bas.strip() == "type error":
return ErreurRomma("type inconnu (Type error)")
return ErreurRomma(scrub(message, cle)[:300])
def lire_reponse(corps, cle, maintenant):
"""-> (stations, avertissements). Chaque station : dict avec id, méta, valide, dh_utc, mesure."""
if isinstance(corps, bytes):
corps = corps.decode("utf-8", errors="replace")
corps = corps.strip().lstrip("")
try:
valeur = json.loads(corps)
except ValueError:
e = _erreur_texte(corps, cle)
if type(e) is ErreurRomma and "Type error" not in str(e):
raise ErreurRomma("ce n'est pas du JSON (début : « %s »)" % scrub(corps, cle)[:120])
raise e
if isinstance(valeur, str):
raise _erreur_texte(valeur, cle)
if not isinstance(valeur, list):
raise ErreurRomma("un tableau de stations était attendu")
stations, avert = [], []
for rang, obj in enumerate(valeur, 1):
if not isinstance(obj, dict):
avert.append("élément n°%d ignoré : ce n'est pas une station" % rang)
continue
sid = texte(obj, "id_station")
if not sid:
avert.append("élément n°%d ignoré : pas d'id_station" % rang)
continue
qui = texte(obj, "station") or "station %s" % sid
local = lire_date_heure(texte(obj, "date") or "", texte(obj, "heure") or "")
dh = None
if local is None:
avert.append("%s : date illisible" % qui)
else:
dh = paris_vers_utc(local, maintenant)
if dh is None:
avert.append("%s : heure inexistante à Paris (passage à l'heure d'été)" % qui)
elif (dh - maintenant).total_seconds() > AVANCE_TOLEREE_S:
avert.append("%s : mesure datée dans le futur, ignorée" % qui)
dh = None
direction = nombre(obj, "vent_direction_degres")
if direction is not None:
direction %= 360
else:
direction = ROSE.get((texte(obj, "vent_direction") or "").upper())
stations.append({
"id": sid, "nom": texte(obj, "station"), "departement": texte(obj, "departement"),
"altitude": nombre(obj, "altitude"), "lat": nombre(obj, "latitude"), "lon": nombre(obj, "longitude"),
"valide": (nombre(obj, "is_valide") or 0) != 0, # absent : on ne présume pas la validité
"dh_utc": fmt_utc(dh) if dh else None,
"mesure": {"temperature": nombre(obj, "temperature"), "humidite": nombre(obj, "humidite"),
"pression": nombre(obj, "pression"), "vent_moyen": nombre(obj, "vent_moyen_10min"),
"vent_rafales": nombre(obj, "vent_rafale_maxi_10min"), "vent_direction": direction,
"rayonnement": nombre(obj, "radiation"), "pluie_cumul": nombre(obj, "pluie_jour")},
})
return stations, avert
def motif_exclusion(st):
if not st["valide"]:
return "mesure marquée non valide par ROMMA (is_valide = 0)"
if not st["dh_utc"]:
return "horodatage inutilisable"
if st["mesure"]["temperature"] is None:
return "pas de température"
return None
def telecharger(url):
r = urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": UA}), timeout=30)
return r.read()
def passer(cfg, stockage, journal, maintenant, fetch=telecharger):
"""Un tick ROMMA : au plus un appel global=1 toutes les 10 min ; un échec bloque aussi 10 min, plus la
pause de 15 min commune à toutes les sources."""
var = cfg.base / "var"
fichier_etat = var / "etat_romma.json"
etat = lire_json(fichier_etat, {})
pause = Pause(var / "pause_romma.txt")
resume = {"source": SOURCE, "action": "rien", "requetes": 0}
if pause.active(maintenant):
resume.update(action="pause", jusqua=fmt_utc(pause.jusqua()))
return resume
dernier = etat.get("dernier_appel_utc")
if dernier and (maintenant - dt.datetime.strptime(dernier, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
).total_seconds() < INTERVALLE_MIN_S - 30:
return resume
try:
cle = lire_secret(cfg.cle_romma)
except OSError:
resume["action"] = "sans_cle" # opt-in : sans clé, aucun appel
return resume
journal.masquer(cle)
j = jour_paris(maintenant)
if etat.get("jour") != j:
etat["jour"], etat["requetes_jour"] = j, 0
etat["dernier_appel_utc"] = fmt_utc(maintenant)
etat["requetes_jour"] += 1
ecrire_json(fichier_etat, etat, compact=False) # noté AVANT l'appel : un plantage ne fait pas rappeler
resume["requetes"] = 1
try:
stations, avert = lire_reponse(fetch(construire_url(cle)), cle, maintenant)
except Exception as e:
pause.poser(maintenant)
msg = scrub(str(e), cle)[:300]
journal("ERREUR ROMMA (requête %d du jour) : %s ; pause 15 min" % (etat["requetes_jour"], msg), maintenant)
resume.update(action="erreur", erreur=msg[:200])
return resume
nouvelles, exclues = 0, 0
for st in stations:
stockage.maj_station(SOURCE, st["id"], nom=st["nom"], lat=st["lat"], lon=st["lon"], altitude=st["altitude"],
licence="ROMMA (pas de revente, source citée)", lien=page_station(st["id"]),
extra=json.dumps({"departement": st["departement"]}, ensure_ascii=False))
if motif_exclusion(st):
exclues += 1
continue
nouvelles += stockage.ajouter(SOURCE, st["id"], [dict(st["mesure"], dh_utc=st["dh_utc"])], maintenant)
etat["dernier_succes_utc"] = fmt_utc(maintenant)
ecrire_json(fichier_etat, etat, compact=False)
for a in avert[:10]:
journal("ROMMA : " + a, maintenant)
journal("ok ROMMA (requête %d du jour) : %d station(s), %d mesure(s) nouvelle(s), %d écartée(s)"
% (etat["requetes_jour"], len(stations), nouvelles, exclues), maintenant)
resume.update(action="appel", stations=len(stations), nouvelles=nouvelles, exclues=exclues)
return resume
+1
Voir le fichier
@@ -0,0 +1 @@
"Erreur : no user associated or apikey invalid"
+57
Voir le fichier
@@ -0,0 +1,57 @@
[
{
"id_station": 9001,
"station": "Station fictive A",
"departement": "38, Is\u00e8re",
"altitude": 1000,
"latitude": 45.1,
"longitude": 5.6,
"is_valide": 1,
"date": "16\/10\/26",
"heure": "13:50",
"temperature": 8.8,
"pluie_jour": "1.4",
"pression": 1019.8,
"humidite": "NULL",
"radiation": "NULL",
"vent_moyen_10min": 3,
"vent_direction": "SSO",
"vent_direction_degres": "NULL",
"vent_rafale_maxi": 25.7,
"vent_rafale_maxi_10min": 7.2,
"neige": "NULL"
},
{
"id_station": "9002",
"station": "Station fictive B",
"altitude": "1450",
"latitude": "45.09",
"longitude": "5.603",
"is_valide": 0,
"date": "16\/10\/26",
"heure": "13:50",
"temperature": 5.0
},
{
"id_station": 9003,
"station": "Station fictive C",
"is_valide": 1,
"date": "16\/10\/26",
"heure": "13:50",
"temperature": "NULL"
},
{
"id_station": 9004,
"station": "Station fictive D",
"is_valide": "1",
"date": "16\/10\/2026",
"heure": "13:40",
"temperature": "6,5",
"radiation": 0,
"vent_direction_degres": 370
},
"pas une station",
{
"station": "sans id"
}
]
+120
Voir le fichier
@@ -0,0 +1,120 @@
import tempfile
import unittest
import urllib.parse
from pathlib import Path
from meteo_collecte import romma
from meteo_collecte.stockage import Stockage
from tests.aide import CLE_FICTIVE, FauxReseau, config, fixture, t
APPEL = t(11, 55) # 13:55 à Paris (heure d'été)
class TestLecture(unittest.TestCase):
def setUp(self):
self.st, self.av = romma.lire_reponse(fixture("romma_live.json"), "K", APPEL)
self.par_id = {s["id"]: s for s in self.st}
def test_heure_de_paris_vers_utc(self):
self.assertEqual(self.par_id["9001"]["dh_utc"], "2026-10-16 11:50:00")
self.assertEqual(self.par_id["9004"]["dh_utc"], "2026-10-16 11:40:00") # année sur 4 chiffres
def test_null_texte_n_est_pas_zero(self):
m = self.par_id["9001"]["mesure"]
self.assertIsNone(m["humidite"])
self.assertIsNone(m["rayonnement"])
self.assertEqual(self.par_id["9004"]["mesure"]["rayonnement"], 0.0)
self.assertEqual(self.par_id["9004"]["mesure"]["temperature"], 6.5)
def test_pluie_jour_est_un_cumul(self):
m = self.par_id["9001"]["mesure"]
self.assertEqual(m["pluie_cumul"], 1.4)
self.assertNotIn("pluie_1h", m)
def test_direction(self):
self.assertEqual(self.par_id["9001"]["mesure"]["vent_direction"], 202.5) # rose SSO
self.assertEqual(self.par_id["9004"]["mesure"]["vent_direction"], 10.0) # 370 -> 10
def test_is_valide_et_exclusions(self):
self.assertIn("is_valide", romma.motif_exclusion(self.par_id["9002"]))
self.assertEqual(romma.motif_exclusion(self.par_id["9003"]), "pas de température")
self.assertIsNone(romma.motif_exclusion(self.par_id["9001"]))
self.assertEqual(len(self.av), 2) # deux éléments ignorés
def test_vraies_coordonnees(self):
self.assertEqual((self.par_id["9002"]["lat"], self.par_id["9002"]["altitude"]), (45.09, 1450.0))
def test_erreurs_texte_en_http_200(self):
with self.assertRaises(romma.CleRefusee):
romma.lire_reponse(fixture("romma_cle_refusee.json"), "K", APPEL)
with self.assertRaises(romma.CleRefusee):
romma.lire_reponse("Erreur : no user associated or apikey invalid", "K", APPEL)
with self.assertRaises(romma.ErreurRomma):
romma.lire_reponse('"Type error"', "K", APPEL)
with self.assertRaises(romma.ErreurRomma) as c:
romma.lire_reponse('"Erreur : quota SECRET42"', "SECRET42", APPEL)
self.assertNotIn("SECRET42", str(c.exception))
with self.assertRaises(romma.ErreurRomma):
romma.lire_reponse("<html>", "K", APPEL)
with self.assertRaises(romma.ErreurRomma):
romma.lire_reponse('{"a":1}', "K", APPEL)
self.assertEqual(romma.lire_reponse("[]", "K", APPEL), ([], []))
def test_futur_et_heure_inexistante(self):
st, av = romma.lire_reponse('[{"id_station":1,"is_valide":1,"date":"29/03/26","heure":"02:30",'
'"temperature":1},{"id_station":2,"is_valide":1,"date":"17/10/26",'
'"heure":"12:00","temperature":1}]', "K", APPEL)
self.assertEqual([s["dh_utc"] for s in st], [None, None])
self.assertEqual(len(av), 2)
def test_lien_station(self):
self.assertEqual(romma.page_station(" 80 "), "https://www.romma.fr/station_24.php?id=80")
self.assertIsNone(romma.page_station("80&x=1"))
def test_url(self):
u = romma.construire_url(CLE_FICTIVE)
self.assertTrue(u.startswith("https://www.romma.fr/api_export.php/?apikey="))
self.assertTrue(u.endswith("&type=live&global=1"))
class TestPassage(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.cfg, self.journal = config(self.tmp.name)
self.s = Stockage(Path(self.tmp.name) / "m.sqlite")
def tearDown(self):
self.s.fermer()
self.tmp.cleanup()
def test_un_appel_toutes_les_10_min(self):
r = romma.passer(self.cfg, self.s, self.journal, APPEL, FauxReseau(fixture("romma_live.json")))
self.assertEqual((r["action"], r["nouvelles"], r["exclues"]), ("appel", 2, 2))
res = FauxReseau(fixture("romma_live.json"))
self.assertEqual(romma.passer(self.cfg, self.s, self.journal, t(12, 0), res)["action"], "rien")
self.assertEqual(res.urls, [])
romma.passer(self.cfg, self.s, self.journal, t(12, 5), res)
self.assertEqual(len(res.urls), 1)
st = {x["station_id"]: x for x in self.s.stations()}
self.assertEqual(st["9001"]["lien"], "https://www.romma.fr/station_24.php?id=9001")
def test_cle_refusee_pause_et_cle_masquee(self):
enc = urllib.parse.quote(CLE_FICTIVE, safe="")
r = romma.passer(self.cfg, self.s, self.journal, APPEL,
FauxReseau(OSError("timeout (https://www.romma.fr/api_export.php/?apikey=%s&type=live)" % enc)))
self.assertEqual(r["action"], "erreur")
texte = (self.cfg.base / "var" / "journal.log").read_text(encoding="utf-8")
self.assertNotIn("FICTIVE", texte)
self.assertNotIn("FICTIVE", r["erreur"])
self.assertEqual(romma.passer(self.cfg, self.s, self.journal, t(12, 6),
FauxReseau(fixture("romma_live.json")))["action"], "pause")
def test_sans_cle_aucun_appel(self):
self.cfg.cle_romma.unlink()
res = FauxReseau(fixture("romma_live.json"))
self.assertEqual(romma.passer(self.cfg, self.s, self.journal, APPEL, res)["action"], "sans_cle")
self.assertEqual(res.urls, [])
if __name__ == "__main__":
unittest.main()