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>
230 lignes
9.3 KiB
Python
230 lignes
9.3 KiB
Python
"""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
|