Fichiers
meteo-vercors/collecte/generer_climat.py
T
Théo GastineletClaude Opus 5.5 574cf2e6f5 Page Climat : générateur des JSON par station et page climat.html
- collecte/generer_climat.py : lit vercors.db en lecture seule (tables horaire et obs),
  écrit data/climat/<id>.json (~1 Ko) et index.json : moyenne annuelle, records,
  jours de gel par hiver, jours de neige au sol (depuis 1963), normale 1991-2020
  ou moyenne des années disponibles, annoncée comme telle.
- maquettes/accueil-carte/climat.html : page claire, SVG fait main, aucune
  ressource externe ; « aujourd'hui » comparé à la normale depuis data/semaine.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 11:21:25 +01:00

330 lignes
13 KiB
Python

#!/usr/bin/env python3
"""Écrit les données de la page « Climat » de vercors.me : un petit JSON par station (data/climat/<id>.json + index.json).
Lit l'archive SQLite EN LECTURE SEULE (aucune écriture dans la base) :
- table horaire (open data Météo-France) : températures horaires depuis 1993-1995 selon le poste,
hauteur de neige au sol (relevé quotidien de 7 h) depuis 1957-1972 pour Gresse, Autrans et Villard ;
- table obs (pas de 10 min) : stations ROMMA et de la famille Gastinel (historique relayé par Infoclimat), et le direct.
Pour chaque station : température moyenne par année, records, jours de gel par hiver, jours de neige au sol par hiver
et la normale saisonnière (1991-2020 si au moins 20 années complètes, sinon la période disponible, annoncée comme telle).
Python standard uniquement. Une fois par jour suffit.
Usage :
python generer_climat.py --db archive/vercors.db --sortie public/data/climat
"""
import argparse
import bisect
import calendar
import datetime as dt
import json
import math
import os
import sys
import tempfile
import sqlite3
# Stations publiées sur la carte (même liste que l'accueil ; rochechinard, marignac, solaure : pas d'autorisation)
STATIONS = {
"autrans": ("Autrans – L'Escandille", 1069, "Météo-France"),
"geve": ("Autrans – Gêve nordique", 1287, "famille Gastinel"),
"engins": ("Engins, le Fournel", 905, "ROMMA"),
"meaudre": ("Méaudre", 976, "famille Gastinel"),
"lans": ("Lans-en-Vercors – village", 1020, "famille Gastinel"),
"bruyeres": ("Lans-en-Vercors – Les Bruyères", 990, "famille Gastinel"),
"allieres": ("Lans-en-Vercors – Les Allières", 1449, "famille Gastinel"),
"villard": ("Villard-de-Lans – Payonère", 1027, "Météo-France"),
"moucherolle": ("Crête de la Moucherolle", 1965, "famille Gastinel"),
"chapelle": ("La Chapelle-en-Vercors – Les Finets", 879, "Météo-France"),
"oscence": ("Combe de l'Oscence", 1000, "famille Gastinel"),
"darbounouse": ("Combe de Darbounouse", 1282, "famille Gastinel"),
"rousset": ("Col du Rousset – plateau de Beurre", 1400, "Météo-France"),
"gresse": ("Gresse-en-Vercors", 1220, "Météo-France"),
"st-jean": ("Saint-Jean-en-Royans", 308, "Météo-France"),
"die": ("Die", 400, "ROMMA"),
"st-julien-q": ("Saint-Julien-en-Quint", 574, "ROMMA"),
"archiane": ("Cirque d'Archiane", 747, "ROMMA"),
}
T_MIN, T_MAX = -35.0, 42.0 # bornes physiques plausibles dans le Vercors
SAUT = 6.0 # pic isolé : écart de plus de 6 °C avec les deux voisins (10 min) -> point ignoré
HEURES_MIN = 20 # une journée compte si au moins 20 heures sur 24 ont une mesure
JOURS_MOIS_AN = 24 # une année compte si chaque mois a au moins 24 journées valides
JOURS_MOIS_GEL = 28 # un hiver compte si chaque mois d'octobre à avril a au moins 28 journées valides
ANS_MIN = 2 # page « climat » : au moins 2 années complètes de température...
HIVERS_NEIGE_MIN = 10 # ...ou au moins 10 hivers de neige au sol
PAS_NORMALE = 5 # normale saisonnière : une valeur tous les 5 jours (73 valeurs, interpolées par la page)
# ---------- heure de Paris (règle européenne, sans dépendre de tzdata) ----------
def _dernier_dimanche(an, mois):
j = calendar.monthrange(an, mois)[1]
while dt.date(an, mois, j).weekday() != 6:
j -= 1
return j
_BASCULES = [] # instants UTC des changements d'heure (1976-2040) ; avant 1976 : pas d'heure d'été en France
for _a in range(1976, 2041):
for _m, _h in ((3, 1), (10, 1)):
_BASCULES.append(int(dt.datetime(_a, _m, _dernier_dimanche(_a, _m), _h, tzinfo=dt.timezone.utc).timestamp()))
# 1976-1995 : fin de l'heure d'été fin septembre (règle de l'époque)
for _a in range(1976, 1996):
_BASCULES[(_a - 1976) * 2 + 1] = int(dt.datetime(_a, 9, _dernier_dimanche(_a, 9), 1, tzinfo=dt.timezone.utc).timestamp())
def jour_local(ts):
"""Numéro du jour local (Europe/Paris) : jours depuis le 1/1/1970."""
ete = bisect.bisect_right(_BASCULES, ts) % 2 == 1
return (ts + (7200 if ete else 3600)) // 86400
def date_du_jour(n):
return dt.date(1970, 1, 1) + dt.timedelta(days=n)
# ---------- relevés -> journées (Tn, Tx) ----------
class Jours:
"""Accumule min, max et heures couvertes par jour local."""
def __init__(self):
self.tn, self.tx, self.h = {}, {}, {}
def ajoute(self, ts, bas, haut):
j = jour_local(ts)
if j in self.tn:
if bas < self.tn[j]:
self.tn[j] = bas
if haut > self.tx[j]:
self.tx[j] = haut
self.h[j].add(ts // 3600)
else:
self.tn[j], self.tx[j], self.h[j] = bas, haut, {ts // 3600}
def valides(self):
"""{jour: (tn, tx)} des journées assez complètes et cohérentes."""
out = {}
for j, hs in self.h.items():
tn, tx = self.tn[j], self.tx[j]
if len(hs) >= HEURES_MIN and tx - tn <= 35:
out[j] = (tn, tx)
return out
def jours_horaire(db, sid):
"""Table horaire Météo-France : TN/TX horaires (sinon la température de l'heure). ts = fin de l'heure."""
acc = Jours()
for ts, t, tn, tx in db.execute("SELECT ts, t, tn, tx FROM horaire WHERE id = ? AND (t IS NOT NULL OR tn IS NOT NULL) ORDER BY ts", (sid,)):
bas = tn if tn is not None else t
haut = tx if tx is not None else t
if bas is None or haut is None or not (T_MIN <= bas <= T_MAX and T_MIN <= haut <= T_MAX):
continue
acc.ajoute(ts - 1800, bas, haut) # milieu de l'heure écoulée
return acc.valides()
def jours_obs(db, sid):
"""Table obs (10 min) : min et max des mesures, pics isolés écartés."""
acc = Jours()
pts = [(ts, t) for ts, t in db.execute("SELECT ts, t FROM obs WHERE id = ? AND t IS NOT NULL ORDER BY ts", (sid,))
if T_MIN <= t <= T_MAX]
for i, (ts, t) in enumerate(pts):
av = pts[i - 1] if i else None
ap = pts[i + 1] if i + 1 < len(pts) else None
if (av and ap and ts - av[0] <= 1800 and ap[0] - ts <= 1800
and abs(t - av[1]) > SAUT and abs(t - ap[1]) > SAUT and (t - av[1]) * (t - ap[1]) > 0):
continue
acc.ajoute(ts, t, t)
return acc.valides()
def neige_hivers(db, sid):
"""Jours avec au moins 1 cm de neige au sol (relevé de 7 h, 06 UTC), d'octobre à mai : {hiver: jours}."""
par_jour = {}
for ts, n in db.execute("SELECT ts, neige FROM horaire WHERE id = ? AND neige IS NOT NULL AND ((ts % 86400) + 86400) % 86400 = 21600", (sid,)):
par_jour[ts // 86400] = n
hivers = {}
for j, n in par_jour.items():
d = date_du_jour(j)
if d.month in (6, 7, 8, 9):
continue
h = d.year if d.month >= 10 else d.year - 1
hivers.setdefault(h, [0, 0])
hivers[h][0] += 1
hivers[h][1] += n >= 1
out = {}
for h, (presents, neige) in hivers.items():
total = (dt.date(h + 1, 6, 1) - dt.date(h, 10, 1)).days
if presents >= 0.95 * total:
out[h] = neige
return out
# ---------- statistiques ----------
def par_mois(jours):
"""{(an, mois): nombre de journées valides}"""
c = {}
for j in jours:
d = date_du_jour(j)
c[(d.year, d.month)] = c.get((d.year, d.month), 0) + 1
return c
def annees(jours):
"""{an: moyenne de (Tn+Tx)/2} pour les années complètes."""
cm = par_mois(jours)
som = {}
for j, (tn, tx) in jours.items():
a = date_du_jour(j).year
s = som.setdefault(a, [0.0, 0])
s[0] += (tn + tx) / 2
s[1] += 1
return {a: s / n for a, (s, n) in som.items() if all(cm.get((a, m), 0) >= JOURS_MOIS_AN for m in range(1, 13))}
def gel_hivers(jours):
"""{hiver (année de juillet): jours avec Tn <= 0 °C de juillet à juin} pour les hivers complets."""
cm = par_mois(jours)
som = {}
for j, (tn, _) in jours.items():
d = date_du_jour(j)
h = d.year if d.month >= 7 else d.year - 1
som[h] = som.get(h, 0) + (tn <= 0)
mois = [(0, 10), (0, 11), (0, 12), (1, 1), (1, 2), (1, 3), (1, 4)]
return {h: n for h, n in som.items() if all(cm.get((h + da, m), 0) >= JOURS_MOIS_GEL for da, m in mois)}
def doy365(d):
"""Rang du jour dans une année de 365 jours (le 29 février compte comme le 28)."""
if d.month == 2 and d.day == 29:
d = d.replace(day=28)
return (d - dt.date(d.year, 1, 1)).days - (1 if calendar.isleap(d.year) and d.month > 2 else 0)
def cycle(valeurs_par_doy, harmoniques=3):
"""Cycle annuel lissé (série de Fourier, 3 harmoniques) échantillonné tous les PAS_NORMALE jours."""
pts = [(k, sum(v) / len(v)) for k, v in valeurs_par_doy.items() if v]
if len(pts) < 300:
return None
n = 365.0
a0 = sum(v for _, v in pts) / len(pts)
coef = []
for h in range(1, harmoniques + 1):
ca = 2 * sum(v * math.cos(2 * math.pi * h * k / n) for k, v in pts) / len(pts)
sa = 2 * sum(v * math.sin(2 * math.pi * h * k / n) for k, v in pts) / len(pts)
coef.append((ca, sa))
out = []
for k in range(0, 365, PAS_NORMALE):
v = a0 + sum(ca * math.cos(2 * math.pi * h * k / n) + sa * math.sin(2 * math.pi * h * k / n)
for h, (ca, sa) in enumerate(coef, 1))
out.append(round(v * 10))
return out
def normale(jours, ans, gel):
"""Normale 1991-2020 si au moins 20 années complètes dans cette période, sinon toutes les années complètes."""
dans = [a for a in ans if 1991 <= a <= 2020]
if len(dans) >= 20:
choix, officielle = dans, True
elif len(ans) >= ANS_MIN:
choix, officielle = sorted(ans), False
else:
return None
de, a = min(choix), max(choix)
tn_d, tx_d = {}, {}
for j, (tn, tx) in jours.items():
d = date_du_jour(j)
if de <= d.year <= a:
k = doy365(d)
tn_d.setdefault(k, []).append(tn)
tx_d.setdefault(k, []).append(tx)
ctn, ctx = cycle(tn_d), cycle(tx_d)
if not ctn:
return None
hg = [n for h, n in gel.items() if de <= h <= a] if officielle else list(gel.values())
return {
"officielle": officielle, "de": de, "a": a, "n": len(choix),
"moy": round(sum(ans[x] for x in choix) / len(choix), 1),
"gel": round(sum(hg) / len(hg)) if hg else None,
"pas": PAS_NORMALE, "tn": ctn, "tx": ctx,
}
def serie(d):
"""{clé: valeur} -> [première clé, [valeurs ou null]] (trous compris), valeurs en dixièmes si flottantes."""
if not d:
return None
a, b = min(d), max(d)
return [a, [(round(d[k] * 10) if isinstance(d[k], float) else d[k]) if k in d else None for k in range(a, b + 1)]]
def station(db, sid):
nom, alt, src = STATIONS[sid]
jours = jours_horaire(db, sid)
for j, v in jours_obs(db, sid).items(): # le direct (et les stations non Météo-France) complètent sans écraser
jours.setdefault(j, v)
ans = annees(jours)
gel = gel_hivers(jours)
neige = neige_hivers(db, sid)
if len(ans) < ANS_MIN and len(neige) < HIVERS_NEIGE_MIN:
return None
out = {"id": sid, "nom": nom, "alt": alt, "src": src}
if jours:
jmin = min(jours, key=lambda j: (jours[j][0], j))
jmax = max(jours, key=lambda j: (jours[j][1], -j))
out["t"] = {"de": date_du_jour(min(jours)).isoformat(), "jours": len(jours),
"min": [jours[jmin][0], date_du_jour(jmin).isoformat()],
"max": [jours[jmax][1], date_du_jour(jmax).isoformat()]}
if len(ans) >= ANS_MIN:
out["ans"] = serie(ans)
if gel:
out["gel"] = serie(gel)
if len(neige) >= HIVERS_NEIGE_MIN:
out["neige"] = serie(neige)
nm = normale(jours, ans, gel)
if nm:
out["normale"] = nm
return out
def ecrire_atomique(chemin, obj):
os.makedirs(os.path.dirname(chemin), exist_ok=True)
fd, tmp = tempfile.mkstemp(dir=os.path.dirname(chemin), suffix=".tmp")
with os.fdopen(fd, "w", encoding="utf-8") as f:
json.dump(obj, f, ensure_ascii=False, separators=(",", ":"))
os.chmod(tmp, 0o644)
os.replace(tmp, chemin)
def main(argv=None):
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
ap.add_argument("--db", required=True)
ap.add_argument("--sortie", required=True)
a = ap.parse_args(argv)
chemin = os.path.abspath(os.path.expanduser(a.db))
if not os.path.exists(chemin):
print("base introuvable : %s" % chemin)
return 1
db = sqlite3.connect("file:%s?mode=ro" % chemin.replace("\\", "/"), uri=True) # lecture seule
sortie = os.path.expanduser(a.sortie)
index = {}
for sid in STATIONS:
d = station(db, sid)
cible = os.path.join(sortie, sid + ".json")
if not d:
if os.path.exists(cible):
os.remove(cible)
continue
d["maj"] = dt.date.today().isoformat()
ecrire_atomique(cible, d)
index[sid] = {"nom": d["nom"], "alt": d["alt"],
"t": int(d["t"]["de"][:4]) if "ans" in d else None,
"neige": d["neige"][0] if "neige" in d else None}
ecrire_atomique(os.path.join(sortie, "index.json"), index)
print("climat : %d stations écrites dans %s" % (len(index), sortie))
return 0
if __name__ == "__main__":
sys.exit(main())