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 à :
1 Parent
017dfd9728
révision
35d60a46d6
4 fichiers modifiés
+407
Aucun fichier ne correspond à votre recherche
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
"Erreur : no user associated or apikey invalid"
|
||||
Externe
+57
@@ -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"
|
||||
}
|
||||
]
|
||||
@@ -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()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur