- 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>
195 lignes
7.9 KiB
Python
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())
|