Fichiers
Théo GastineletClaude Opus 5.5 c1e87e91be Secrets lus uniquement dans l'environnement (MC_JETON_INFOCLIMAT, MC_CLE_ROMMA)
Plus aucun fichier de secret : la valeur est lue au moment de l'appel,
jamais copiee, jamais affichee (--config indique seulement definie/absente).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 20:03:53 +02:00

230 lignes
9.3 KiB
Python
Brut Lien permanent Annotations Historique

Ce fichier contient des caractères Unicode invisibles.
Ce fichier contient des caractères Unicode invisibles à l'œil nu, mais peuvent être traités différemment par un ordinateur. Si vous pensez que c'est intentionnel, vous pouvez ignorer cet avertissement. Utilisez le bouton Échappe pour les dévoiler.
"""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, 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 = cfg.secret(cfg.var_cle_romma)
except LookupError:
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