From 35d60a46d6598616db5634d760a4d3fb9781196a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Fri, 16 Oct 2026 18:59:18 +0200 Subject: [PATCH] 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 --- meteo_collecte/romma.py | 229 ++++++++++++++++++++++++++ tests/fixtures/romma_cle_refusee.json | 1 + tests/fixtures/romma_live.json | 57 +++++++ tests/test_romma.py | 120 ++++++++++++++ 4 files changed, 407 insertions(+) create mode 100644 meteo_collecte/romma.py create mode 100644 tests/fixtures/romma_cle_refusee.json create mode 100644 tests/fixtures/romma_live.json create mode 100644 tests/test_romma.py diff --git a/meteo_collecte/romma.py b/meteo_collecte/romma.py new file mode 100644 index 0000000..bf4ca72 --- /dev/null +++ b/meteo_collecte/romma.py @@ -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=&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 diff --git a/tests/fixtures/romma_cle_refusee.json b/tests/fixtures/romma_cle_refusee.json new file mode 100644 index 0000000..1397c82 --- /dev/null +++ b/tests/fixtures/romma_cle_refusee.json @@ -0,0 +1 @@ +"Erreur : no user associated or apikey invalid" \ No newline at end of file diff --git a/tests/fixtures/romma_live.json b/tests/fixtures/romma_live.json new file mode 100644 index 0000000..d46db58 --- /dev/null +++ b/tests/fixtures/romma_live.json @@ -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" + } +] \ No newline at end of file diff --git a/tests/test_romma.py b/tests/test_romma.py new file mode 100644 index 0000000..0ec665d --- /dev/null +++ b/tests/test_romma.py @@ -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("", "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()