Fichiers
meteo-vercors/collecte/collecter_meteofrance.py
T
Théo GastineletClaude Sonnet 5.5 ff42faca16 vercors.me : collecte Météo-France / Infoclimat / VP2, archive SQLite, accueil en carte, forum (squelette)
- collecte : collecter_meteofrance, extraire_infoclimat, extraire_vp2, archiver_historique, importer_opendata ; WeatherLink allégé (alleger)
- tests : meteofrance, infoclimat, vp2, archive, opendata (tous verts)
- maquettes/accueil-carte : sources de la maquette (générateurs de tuiles, page, À propos, CGU, confidentialité)
- forum : noyau local (rôles, droits, SQLite, serveur de test, 18 tests)
- deploy : Caddyfile.vercors.me.v2 (non appliqué)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 02:24:57 +01:00

195 lignes
7.9 KiB
Python

#!/usr/bin/env python3
"""Collecte Météo-France (API Package Observations v2, pas de 6 min) -> JSON public filtré (public/data/meteofrance.json).
Python standard uniquement. Une requête /paquet/infrahoraire-6m par poste : l'API renvoie plusieurs jours,
on garde les 24 dernières heures. Même format que meteo.json (WeatherLink) pour que le site lise les deux.
Clé : variable d'environnement nommée dans config/meteofrance.json (MF_DPPAQUETOBS_CLE), sinon lue dans le
fichier d'environnement indiqué (une ligne NOM=valeur). La valeur n'est jamais affichée ni écrite.
Usage :
python collecter_meteofrance.py # appels réels
options : --sortie CHEMIN --config CHEMIN --fichier-env CHEMIN --heures 24
Données Météo-France : Licence Ouverte Etalab 2.0 (source à citer : Météo-France).
"""
import argparse
import datetime as dt
import json
import os
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from collecter_weatherlink import CHAMPS_PUBLICS, ecrire_atomique, fmt_utc, maintenant, verifier_public # noqa: E402
URL = "https://public-api.meteofrance.fr/public/DPPaquetObs/v2/paquet/infrahoraire-6m"
SOURCE_MF = "Météo-France"
LICENCE_MF = "Météo-France, Licence Ouverte Etalab 2.0"
UA = "vercors.me/0.1 (meteo-vercors)"
RACINE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SORTIE_DEFAUT = os.path.join(RACINE, "public", "data", "meteofrance.json")
CONFIG_DEFAUT = os.path.join(RACINE, "config", "meteofrance.json")
HORS_LIGNE_MIN = 30 # dernier relevé plus vieux que ça : station affichée hors ligne
try:
from zoneinfo import ZoneInfo
PARIS = ZoneInfo("Europe/Paris")
except Exception: # pas de base de fuseaux (Windows sans tzdata) : heure d'hiver
PARIS = dt.timezone(dt.timedelta(hours=1))
class ErreurMF(Exception):
pass
def lire_date(s):
return dt.datetime.strptime(s[:19], "%Y-%m-%dT%H:%M:%S").replace(tzinfo=dt.timezone.utc)
def nombre(v):
return float(v) if isinstance(v, (int, float)) and not isinstance(v, bool) else None
def releve_depuis_mf(r):
"""Un enregistrement Météo-France (unités SI) -> relevé public. None si pas de température."""
t = nombre(r.get("t"))
if t is None or not isinstance(r.get("validity_time"), str):
return None
out = {"dh_utc": fmt_utc(lire_date(r["validity_time"])), "temperature": round(t - 273.15, 1)}
td, u = nombre(r.get("td")), nombre(r.get("u"))
if td is not None:
out["point_de_rosee"] = round(td - 273.15, 1)
if u is not None:
out["humidite"] = int(round(u))
pmer = nombre(r.get("pmer"))
if pmer is not None:
out["pression"] = round(pmer / 100.0, 1) # Pa -> hPa
ff, raf, dd = nombre(r.get("ff")), nombre(r.get("raf10")), nombre(r.get("dd"))
if ff is not None:
out["vent_moyen"] = round(ff * 3.6, 1) # m/s -> km/h
if raf is not None:
out["vent_rafales"] = round(raf * 3.6, 1)
if dd is not None and ff:
out["vent_direction"] = int(round(dd)) % 360
return out
def construire_releves(enregistrements, fin, heures=24):
"""Liste brute Météo-France -> relevés publics des `heures` dernières heures, du plus ancien au plus récent.
Ajoute pluie_1h (somme glissante des 6 min) et pluie_cumul_0h (depuis minuit, heure de Paris)."""
pluies, rel = [], {}
for r in enregistrements if isinstance(enregistrements, list) else []:
if not isinstance(r, dict) or not isinstance(r.get("validity_time"), str):
continue
d = lire_date(r["validity_time"])
rr = nombre(r.get("rr_per"))
if rr is not None:
pluies.append((d, rr))
p = releve_depuis_mf(r)
if p:
rel[p["dh_utc"]] = (d, p)
debut = fin - dt.timedelta(hours=heures)
out = []
for _, (d, p) in sorted(rel.items()):
if d <= debut:
continue
if pluies:
minuit = d.astimezone(PARIS).replace(hour=0, minute=0, second=0).astimezone(dt.timezone.utc)
p["pluie_1h"] = round(sum(v for q, v in pluies if d - dt.timedelta(hours=1) < q <= d), 1)
p["pluie_cumul_0h"] = round(sum(v for q, v in pluies if minuit < q <= d), 1)
out.append(p)
if out:
ts = [p["temperature"] for p in out]
out[-1]["temperature_min"], out[-1]["temperature_max"] = min(ts), max(ts)
return out
def lire_cle(nom_var, fichier_env):
"""Valeur de la clé : variable d'environnement, sinon ligne NOM=valeur du fichier. Rien n'est affiché."""
v = os.environ.get(nom_var, "")
if v or not fichier_env:
return v
try:
with open(os.path.expanduser(fichier_env), encoding="utf-8") as f:
for ligne in f:
nom, _, val = ligne.strip().partition("=")
if nom == nom_var:
return val.strip().strip('"').strip("'")
except OSError:
pass
return ""
def appeler(id_station, cle):
"""Une requête. La clé n'apparaît dans aucun message d'erreur."""
url = "%s?%s" % (URL, urllib.parse.urlencode({"id_station": id_station, "format": "json"}))
req = urllib.request.Request(url, headers={"apikey": cle, "User-Agent": UA, "Accept": "application/json"})
try:
with urllib.request.urlopen(req, timeout=30) as r:
return json.loads(r.read().decode("utf-8", errors="replace"))
except urllib.error.HTTPError as e:
raise ErreurMF("HTTP %d" % e.code)
except ValueError:
raise ErreurMF("réponse non JSON")
except Exception as e:
raise ErreurMF("réseau : %s" % type(e).__name__)
def meta_station(c):
return {"lat": round(c["lat"], 2), "lon": round(c["lon"], 2), "altitude": c["altitude"], "licence": LICENCE_MF}
def collecter(config, cle, heures=24, appel=appeler, pause=1.3):
"""Appels réels (une requête par poste). Un poste en erreur ou muet est marqué hors ligne."""
fin = maintenant()
stations, meta, journal = {}, {}, []
for i, (sid, c) in enumerate(config["stations"].items()):
meta[sid] = meta_station(c)
rel, etat = [], "ok"
if not cle:
etat = "sans clé"
else:
if i and pause:
time.sleep(pause) # quota : 50 requêtes par minute
try:
rel = construire_releves(appel(c["id"], cle), fin, heures)
except ErreurMF as e:
etat = "erreur (%s)" % e
dernier = lire_date(rel[-1]["dh_utc"].replace(" ", "T")) if rel else None
hors_ligne = dernier is None or fin - dernier > dt.timedelta(minutes=HORS_LIGNE_MIN)
if rel and hors_ligne and etat == "ok":
etat = "dernier relevé trop ancien"
stations[sid] = {"nom": c["nom"], "source": SOURCE_MF, "hors_ligne": hors_ligne, "releves": rel}
journal.append("%s: %s (%d relevés)" % (sid, etat, len(rel)))
obj = {"source": LICENCE_MF, "mis_a_jour_utc": fin.strftime("%Y-%m-%dT%H:%M:%SZ"),
"metadonnees": meta, "stations": stations}
return obj, journal
def main(argv=None):
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
ap.add_argument("--sortie", default=SORTIE_DEFAUT)
ap.add_argument("--config", default=CONFIG_DEFAUT)
ap.add_argument("--fichier-env", default=None, help="fichier NOM=valeur (défaut : celui de la config)")
ap.add_argument("--heures", type=float, default=24.0)
a = ap.parse_args(argv)
with open(a.config, encoding="utf-8") as f:
config = json.load(f)
cle = lire_cle(config["var_cle"], a.fichier_env or config.get("fichier_env"))
obj, journal = collecter(config, cle, a.heures)
verifier_public(obj)
for st in obj["stations"].values():
assert all(set(r) <= set(CHAMPS_PUBLICS) for r in st["releves"])
ecrire_atomique(a.sortie, obj)
print("écrit : %s (%d stations)" % (os.path.basename(a.sortie), len(obj["stations"])))
print("; ".join(journal))
return 0
if __name__ == "__main__":
sys.exit(main())