- deploy/generer_direct.py : écrit /direct.txt et /direct.md (identiques) à partir des JSON publiés et de la table STATIONS de l'accueil (aucun nombre fixe de stations) ; > 2 h = « pas de mesure récente » - deploy/recevoir_vercors.py : reprend la version du VPS (climat/) et lance le générateur après chaque réception - vercors-direct.service/.timer : minuteur utilisateur de secours, préparé, non actif (linger requis) - llms.txt, llms-full.txt : direct.txt cité en premier pour la météo actuelle - accueil : <link rel="alternate" type="text/plain" href="/direct.txt"> Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
172 lignes
7.8 KiB
Python
172 lignes
7.8 KiB
Python
#!/usr/bin/env python3
|
|
"""Génère /direct.txt et /direct.md de vercors.me : les valeurs en direct en texte simple, lisibles sans JavaScript.
|
|
|
|
Lit les JSON publics déjà publiés (data/meteofrance.json, infoclimat.json, weatherlink.json, vp2.json) et la liste
|
|
des stations de l'accueil (table STATIONS de index.html : nom, altitude) ; ne contacte aucun service.
|
|
Même choix de source que la carte : pour chaque station, le relevé en ligne le plus récent parmi les fichiers.
|
|
Lancé par recevoir_vercors.py après chaque réception (~ toutes les 6 à 10 min) et par un minuteur utilisateur
|
|
de secours (vercors-direct.timer) pour que « pas de mesure récente » apparaisse même si les envois s'arrêtent.
|
|
|
|
Usage : generer_direct.py [racine du site] (défaut /srv/vercors.me)
|
|
"""
|
|
import datetime as dt
|
|
import json
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
RACINE = sys.argv[1] if len(sys.argv) > 1 else "/srv/vercors.me"
|
|
RECENT = dt.timedelta(hours=2)
|
|
POSTES_MF = {"mf-autrans": "autrans", "mf-villard": "villard", "mf-chapelle": "chapelle",
|
|
"mf-rousset": "rousset", "mf-gresse": "gresse", "mf-st-jean": "st-jean"}
|
|
POINTS = ["N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", "S", "SSO", "SO", "OSO", "O", "ONO", "NO", "NNO"]
|
|
|
|
|
|
def heure_paris(t):
|
|
"""UTC -> heure de Paris (heure d'été : dernier dimanche de mars 1 h UTC -> dernier dimanche d'octobre 1 h UTC)."""
|
|
try:
|
|
from zoneinfo import ZoneInfo
|
|
return t.astimezone(ZoneInfo("Europe/Paris"))
|
|
except Exception:
|
|
def dernier_dimanche(annee, mois):
|
|
j = dt.datetime(annee, mois + 1, 1, 1, tzinfo=dt.timezone.utc) - dt.timedelta(days=1)
|
|
return j - dt.timedelta(days=(j.weekday() + 1) % 7)
|
|
ete = dernier_dimanche(t.year, 3) <= t < dernier_dimanche(t.year, 10)
|
|
return t.astimezone(dt.timezone(dt.timedelta(hours=2 if ete else 1)))
|
|
|
|
|
|
def lire_json(nom):
|
|
try:
|
|
with open(os.path.join(RACINE, "data", nom), encoding="utf-8") as f:
|
|
return json.load(f)
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def tables_accueil():
|
|
"""Stations de la carte (ordre, nom, altitude) et identifiants ROMMA / propriétaires / Météo-France, lus dans index.html."""
|
|
with open(os.path.join(RACINE, "index.html"), encoding="utf-8") as f:
|
|
page = f.read()
|
|
|
|
def bloc(nom):
|
|
m = re.search(r"const " + nom + r" = \{(.*?)\};", page, re.S)
|
|
return m.group(1) if m else ""
|
|
|
|
stations = {}
|
|
for m in re.finditer(r"'([a-z0-9-]+)':\s*\{nom:'((?:[^'\\]|\\.)*)',\s*src:'[^']*',\s*alt:(\d+)", bloc("STATIONS")):
|
|
stations[m.group(1)] = {"nom": m.group(2).replace("\\'", "'"), "alt": int(m.group(3))}
|
|
cles = lambda nom: set(re.findall(r"(?:^|[{,\s])'?([a-z0-9-]+)'?\s*:", bloc(nom)))
|
|
return stations, cles("ROMMA_ID"), cles("PROPRIO"), cles("MF_PAGE")
|
|
|
|
|
|
def licence_courte(l):
|
|
if not l:
|
|
return ""
|
|
if "NC" in l:
|
|
return "CC BY-NC"
|
|
if "CC BY" in l:
|
|
return "CC BY"
|
|
if "Etalab" in l:
|
|
return "Licence Ouverte Etalab 2.0"
|
|
return ""
|
|
|
|
|
|
def nb(v, dec=1):
|
|
return f"{v:.{dec}f}".replace(".", ",")
|
|
|
|
|
|
def main():
|
|
maintenant = dt.datetime.now(dt.timezone.utc)
|
|
stations, romma, proprio, mf_page = tables_accueil()
|
|
if not stations:
|
|
print("table STATIONS introuvable dans index.html", file=sys.stderr)
|
|
return 2
|
|
fichiers = [("meteofrance.json", POSTES_MF), ("infoclimat.json", None), ("weatherlink.json", None), ("vp2.json", {"lans": "lans"})]
|
|
choix = {}
|
|
for nom, correspondance in fichiers:
|
|
d = lire_json(nom)
|
|
if not d or not isinstance(d.get("stations"), dict):
|
|
continue
|
|
for cle, st in d["stations"].items():
|
|
ident = correspondance.get(cle) if correspondance else cle
|
|
if ident not in stations or st.get("hors_ligne") or not st.get("releves"):
|
|
continue
|
|
r = st["releves"][-1]
|
|
try:
|
|
t = dt.datetime.strptime(r["dh_utc"], "%Y-%m-%d %H:%M:%S").replace(tzinfo=dt.timezone.utc)
|
|
except Exception:
|
|
continue
|
|
if ident not in choix or t >= choix[ident][0]: # à égalité, le dernier fichier l'emporte (comme la carte)
|
|
lic = ((d.get("metadonnees") or {}).get(cle) or {}).get("licence", "")
|
|
choix[ident] = (t, r, st.get("source") or "", lic)
|
|
|
|
lignes_txt = []
|
|
for ident, s in stations.items():
|
|
nom = s["nom"]
|
|
commune, _, lieu = nom.partition(" – ")
|
|
titre = f"{commune} ({lieu})" if lieu else commune
|
|
c = choix.get(ident)
|
|
if not c or maintenant - c[0] > RECENT:
|
|
texte = f"{titre}, {s['alt']} m : pas de mesure récente."
|
|
else:
|
|
t, r, source, lic = c
|
|
morceaux = []
|
|
if r.get("temperature") is not None:
|
|
morceaux.append(f"{nb(r['temperature'])} °C")
|
|
h = r.get("humidite")
|
|
if h is not None and 5 <= h <= 100: # Bruyères WeatherLink envoie 1 % (capteur hors service) : ignoré
|
|
morceaux.append(f"humidité {round(h)} %")
|
|
vent = []
|
|
if r.get("vent_moyen") is not None:
|
|
vent.append(f"vent moyen {round(r['vent_moyen'])} km/h")
|
|
if r.get("vent_rafales") is not None:
|
|
vent.append(f"rafales {round(r['vent_rafales'])} km/h")
|
|
if r.get("vent_direction") is not None and vent:
|
|
deg = r["vent_direction"] % 360
|
|
vent.append(f"direction {POINTS[round(deg / 22.5) % 16]} ({round(deg)}°)")
|
|
if vent:
|
|
morceaux.append(", ".join(vent))
|
|
if r.get("pluie_1h") is not None:
|
|
morceaux.append(f"pluie {nb(r['pluie_1h'])} mm en 1 h")
|
|
if r.get("pluie_cumul_0h") is not None:
|
|
morceaux.append(f"{nb(r['pluie_cumul_0h'])} mm depuis minuit")
|
|
if ident in romma and ident not in mf_page and ident not in proprio:
|
|
src = "ROMMA (relais Infoclimat)"
|
|
else:
|
|
src = source
|
|
lc = licence_courte(lic)
|
|
if lc and lc not in src:
|
|
src += f", {lc}"
|
|
hp = heure_paris(t)
|
|
texte = (f"{titre}, {s['alt']} m : " + (" ; ".join(morceaux) or "aucune grandeur mesurée")
|
|
+ f". Mesure de {hp:%H:%M} (heure de Paris, le {hp:%d/%m}). Source : {src}.")
|
|
lignes_txt.append("- " + texte)
|
|
|
|
gen = heure_paris(maintenant)
|
|
entete = [
|
|
"Météo Vercors (https://vercors.me) : valeurs en direct",
|
|
"",
|
|
"Mesures réelles des stations du massif du Vercors (pas de prévision). Texte simple mis à jour toutes les 10 minutes environ.",
|
|
f"Généré le {gen:%d/%m/%Y à %H:%M} (heure de Paris, UTC{gen.strftime('%z')[:3]}:{gen.strftime('%z')[3:]}).",
|
|
"Une station sans relevé depuis plus de 2 heures est marquée « pas de mesure récente ».",
|
|
"Licences : Météo-France, Licence Ouverte Etalab 2.0 ; ROMMA, avec l'accord de l'association (relais Infoclimat) ;"
|
|
" Infoclimat, CC BY ou CC BY-NC selon la station (indiquée sur chaque ligne) ; stations Gastinel (Davis Vantage Pro2 et WeatherLink),"
|
|
" données des exploitants. Citez « Météo Vercors (vercors.me) », la source et l'heure de la mesure.",
|
|
"Vent en km/h, pluie en mm. Données détaillées (JSON) : https://vercors.me/llms-full.txt",
|
|
"",
|
|
"Stations :",
|
|
]
|
|
txt = "\n".join(entete + lignes_txt) + "\n"
|
|
for nom, contenu in (("direct.txt", txt), ("direct.md", txt)): # /direct.md : même texte (déjà lisible en Markdown)
|
|
cible = os.path.join(RACINE, nom)
|
|
tmp = cible + ".tmp"
|
|
with open(tmp, "w", encoding="utf-8", newline="\n") as f:
|
|
f.write(contenu)
|
|
os.chmod(tmp, 0o644)
|
|
os.replace(tmp, cible)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|