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>
Cette révision appartient à :
1 Parent
956d08ffd7
révision
ff42faca16
42 fichiers modifiés
+5127
Aucun fichier ne correspond à votre recherche
@@ -1,3 +1,8 @@
|
||||
__pycache__/
|
||||
*.tmp
|
||||
.env*
|
||||
__pycache__/
|
||||
*.pyc
|
||||
site-v2/
|
||||
maquettes/accueil-carte/tuiles/
|
||||
maquettes/accueil-carte/*.png
|
||||
@@ -0,0 +1,148 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Archive les relevés des stations de vercors.me (SQLite, un point toutes les 10 minutes, jamais purgé)
|
||||
et écrit les courbes des 7 derniers jours pour la page (public/data/semaine/<id>.json + index.json).
|
||||
|
||||
Entrées : les JSON publics des collecteurs (même format que meteo.json), lus dans l'ordre : le dernier fichier
|
||||
l'emporte quand deux sources donnent le même point. Python standard uniquement, aucun appel réseau.
|
||||
|
||||
Usage :
|
||||
python archiver_historique.py --db archive/vercors.db --sortie public/data/semaine \
|
||||
--entree infoclimat.json --entree meteofrance.json:mf --entree weatherlink.json
|
||||
« :mf » = les identifiants mf-xxx deviennent ceux du site (voir CORRESPONDANCE_MF).
|
||||
"""
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import json
|
||||
import os
|
||||
import sqlite3
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from collecter_weatherlink import ecrire_atomique # noqa: E402
|
||||
|
||||
PAS_ARCHIVE = 600 # un point par tranche de 10 minutes
|
||||
PAS_SORTIE = 1800 # courbes de la page : un point toutes les 30 minutes
|
||||
JOURS = 7
|
||||
CORRESPONDANCE_MF = {"mf-autrans": "autrans", "mf-villard": "villard", "mf-chapelle": "chapelle",
|
||||
"mf-rousset": "rousset", "mf-gresse": "gresse", "mf-st-jean": "st-jean"}
|
||||
# colonne de la base <- champ du JSON public
|
||||
CHAMPS = (("t", "temperature"), ("h", "humidite"), ("td", "point_de_rosee"), ("p", "pression"),
|
||||
("v", "vent_moyen"), ("raf", "vent_rafales"), ("dir", "vent_direction"), ("r1", "pluie_1h"))
|
||||
|
||||
SCHEMA = """CREATE TABLE IF NOT EXISTS obs (
|
||||
id TEXT NOT NULL, ts INTEGER NOT NULL,
|
||||
t REAL, h REAL, td REAL, p REAL, v REAL, raf REAL, dir REAL, r1 REAL,
|
||||
PRIMARY KEY (id, ts)) WITHOUT ROWID"""
|
||||
|
||||
|
||||
def epoch(dh_utc):
|
||||
d = dt.datetime.strptime(dh_utc[:19].replace("T", " "), "%Y-%m-%d %H:%M:%S").replace(tzinfo=dt.timezone.utc)
|
||||
return int(d.timestamp())
|
||||
|
||||
|
||||
def ouvrir(chemin):
|
||||
os.makedirs(os.path.dirname(os.path.abspath(chemin)), exist_ok=True)
|
||||
db = sqlite3.connect(chemin)
|
||||
db.execute(SCHEMA)
|
||||
return db
|
||||
|
||||
|
||||
def ingerer(db, source, correspondance=None):
|
||||
"""Ajoute les relevés d'un JSON public. Une valeur vide ne remplace jamais une valeur déjà connue."""
|
||||
n = 0
|
||||
cols = [c for c, _ in CHAMPS]
|
||||
sql = ("INSERT INTO obs (id, ts, %s) VALUES (?, ?, %s) ON CONFLICT(id, ts) DO UPDATE SET %s" %
|
||||
(", ".join(cols), ", ".join("?" * len(cols)), ", ".join("%s = COALESCE(excluded.%s, %s)" % (c, c, c) for c in cols)))
|
||||
for sid, st in (source.get("stations") or {}).items():
|
||||
site = (correspondance or {}).get(sid, sid)
|
||||
for r in st.get("releves") or []:
|
||||
if not isinstance(r, dict) or not isinstance(r.get("dh_utc"), str) or r.get("temperature") is None:
|
||||
continue
|
||||
try:
|
||||
ts = epoch(r["dh_utc"]) // PAS_ARCHIVE * PAS_ARCHIVE
|
||||
except ValueError:
|
||||
continue
|
||||
vals = [r.get(champ) if isinstance(r.get(champ), (int, float)) else None for _, champ in CHAMPS]
|
||||
db.execute(sql, [site, ts] + vals)
|
||||
n += 1
|
||||
db.commit()
|
||||
return n
|
||||
|
||||
|
||||
def moyenne(valeurs):
|
||||
v = [x for x in valeurs if x is not None]
|
||||
return round(sum(v) / len(v), 1) if v else None
|
||||
|
||||
|
||||
def courbes(db, maintenant, jours=JOURS):
|
||||
"""{id: courbes alignées sur des tranches de 30 min} pour les `jours` derniers jours."""
|
||||
fin = maintenant // PAS_SORTIE * PAS_SORTIE
|
||||
debut = fin - jours * 86400
|
||||
n = (fin - debut) // PAS_SORTIE + 1
|
||||
out = {}
|
||||
for (sid,) in db.execute("SELECT DISTINCT id FROM obs").fetchall():
|
||||
lignes = db.execute("SELECT ts, t, h, v, r1 FROM obs WHERE id = ? AND ts >= ? ORDER BY ts", (sid, debut)).fetchall()
|
||||
if not lignes:
|
||||
continue
|
||||
cases = [[] for _ in range(n)]
|
||||
pluie = [None] * n
|
||||
for ts, t, h, v, r1 in lignes:
|
||||
i = (ts - debut) // PAS_SORTIE
|
||||
if 0 <= i < n:
|
||||
cases[i].append((t, h, v))
|
||||
if r1 is not None and ts % 3600 < PAS_ARCHIVE: # pluie des 60 dernières minutes, relevée à l'heure pile
|
||||
pluie[i] = r1
|
||||
courbe = {
|
||||
"id": sid, "debut": debut, "pas": PAS_SORTIE,
|
||||
"t": [moyenne(c[0] for c in cs) for cs in cases],
|
||||
"h": [moyenne(c[1] for c in cs) for cs in cases],
|
||||
"v": [moyenne(c[2] for c in cs) for cs in cases],
|
||||
"r": pluie,
|
||||
}
|
||||
courbe["capteurs"] = {"vent": any(x is not None for x in courbe["v"]),
|
||||
"pluie": any(x is not None for x in courbe["r"]),
|
||||
"humidite": any(x is not None for x in courbe["h"])}
|
||||
premier = db.execute("SELECT MIN(ts) FROM obs WHERE id = ?", (sid,)).fetchone()[0]
|
||||
courbe["archive_depuis"] = premier
|
||||
out[sid] = courbe
|
||||
return out
|
||||
|
||||
|
||||
def ecrire(dossier, maintenant, db):
|
||||
cb = courbes(db, maintenant)
|
||||
index = {}
|
||||
for sid, c in cb.items():
|
||||
ecrire_atomique(os.path.join(dossier, sid + ".json"), c)
|
||||
index[sid] = {"vent": c["capteurs"]["vent"], "pluie": c["capteurs"]["pluie"],
|
||||
"depuis": c["archive_depuis"], "points": sum(x is not None for x in c["t"])}
|
||||
ecrire_atomique(os.path.join(dossier, "index.json"), index)
|
||||
return index
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
ap.add_argument("--db", required=True)
|
||||
ap.add_argument("--sortie", required=True)
|
||||
ap.add_argument("--entree", action="append", default=[], help="FICHIER[:mf] ; plusieurs fois, le dernier l'emporte")
|
||||
ap.add_argument("--dossier-entrees", default=".")
|
||||
a = ap.parse_args(argv)
|
||||
db = ouvrir(os.path.expanduser(a.db))
|
||||
total = 0
|
||||
for spec in a.entree:
|
||||
chemin, _, option = spec.partition(":")
|
||||
chemin = os.path.join(os.path.expanduser(a.dossier_entrees), chemin)
|
||||
try:
|
||||
with open(chemin, encoding="utf-8") as f:
|
||||
source = json.load(f)
|
||||
except (OSError, ValueError):
|
||||
print("illisible : %s" % os.path.basename(chemin))
|
||||
continue
|
||||
total += ingerer(db, source, CORRESPONDANCE_MF if option == "mf" else None)
|
||||
index = ecrire(os.path.expanduser(a.sortie), int(dt.datetime.now(dt.timezone.utc).timestamp()), db)
|
||||
lignes = db.execute("SELECT COUNT(*) FROM obs").fetchone()[0]
|
||||
print("archive : %d relevés lus, %d points en base, %d stations écrites" % (total, lignes, len(index)))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,194 @@
|
||||
#!/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())
|
||||
@@ -165,6 +165,21 @@ def fusionner(anciens, nouveau, jours):
|
||||
return [par_date[d] for d in sorted(par_date) if d >= limite]
|
||||
|
||||
|
||||
def alleger(releves, ref=None, recent_min=15, pas_s=600):
|
||||
"""Garde tous les relevés des `recent_min` dernières minutes, puis un seul par tranche de `pas_s` secondes
|
||||
(le plus récent de la tranche). Un relevé toutes les 30 s sur 24 h ferait un fichier de plus de 800 Ko."""
|
||||
ref = ref or maintenant()
|
||||
limite = fmt_utc(ref - dt.timedelta(minutes=recent_min))
|
||||
tranches, out = {}, []
|
||||
for r in releves:
|
||||
if r["dh_utc"] >= limite:
|
||||
out.append(r)
|
||||
else:
|
||||
d = dt.datetime.strptime(r["dh_utc"], "%Y-%m-%d %H:%M:%S").replace(tzinfo=dt.timezone.utc)
|
||||
tranches[int(d.timestamp()) // pas_s] = r
|
||||
return sorted(list(tranches.values()) + out, key=lambda r: r["dh_utc"])
|
||||
|
||||
|
||||
def min_max_jour(releves):
|
||||
"""Min/max de temperature sur les 24 dernieres heures du JSON (recalcules, pas fournis par l'API)."""
|
||||
ts = [r["temperature"] for r in releves if "temperature" in r]
|
||||
@@ -184,6 +199,7 @@ def ecrire_atomique(chemin, obj):
|
||||
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) # fichier public : le serveur web doit pouvoir le lire (mkstemp crée en 0600)
|
||||
os.replace(tmp, chemin)
|
||||
|
||||
|
||||
@@ -272,6 +288,7 @@ def collecter(config, ancien, jours, fichier_cles=None):
|
||||
rel = fusionner(hist, nouveau, jours)
|
||||
if rel and nouveau:
|
||||
rel[-1]["temperature_min"], rel[-1]["temperature_max"] = min_max_jour(rel)
|
||||
rel = alleger(rel)
|
||||
stations[sid] = {"nom": c["nom"], "source": SOURCE_WL, "hors_ligne": nouveau is None, "releves": rel}
|
||||
journal.append("%s: %s" % (sid, etat))
|
||||
obj = {"source": "WeatherLink (Davis Instruments)", "mis_a_jour_utc": fin.strftime("%Y-%m-%dT%H:%M:%SZ"),
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Extrait les stations du Vercors du fichier Infoclimat déjà collecté sur le LAN (meteo-direct/www/direct.json)
|
||||
-> JSON public filtré (public/data/infoclimat.json), même format que meteo.json et meteofrance.json.
|
||||
|
||||
Aucun appel réseau : la collecte Infoclimat tourne ailleurs (cron recuperer.sh, toutes les 5 min).
|
||||
On garde les 24 dernières heures, seulement les champs publics, sans valeur vide.
|
||||
|
||||
Usage :
|
||||
python extraire_infoclimat.py --source ~/services/meteo-direct/www/direct.json --sortie CHEMIN
|
||||
|
||||
Licences : celles d'Infoclimat, station par station (CC BY ou CC BY-NC) ; recopiées dans les métadonnées.
|
||||
"""
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from collecter_weatherlink import CHAMPS_PUBLICS, charger_json, ecrire_atomique, maintenant, verifier_public # noqa: E402
|
||||
|
||||
RACINE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
SORTIE_DEFAUT = os.path.join(RACINE, "public", "data", "infoclimat.json")
|
||||
HORS_LIGNE_MIN = 40 # Infoclimat publie toutes les 10 min, avec du retard
|
||||
|
||||
# identifiant du site -> identifiant Infoclimat (ou VP2 : station Gastinel, passée par le même fichier)
|
||||
STATIONS = {
|
||||
"bruyeres": "000T0", "allieres": "000GS", "engins": "000HT", "meaudre": "000IA", "geve": "000IL",
|
||||
"lans": "VP2", "moucherolle": "STATIC0479", "darbounouse": "STATIC0213", "oscence": "000UF",
|
||||
"die": "000PD", "st-julien-q": "000OS", "marignac": "STATIC0203", "archiane": "000ZK",
|
||||
"rochechinard": "STATIC0238", "solaure": "STATIC0323",
|
||||
}
|
||||
|
||||
|
||||
def lire_date(s):
|
||||
return dt.datetime.strptime(s[:19], "%Y-%m-%d %H:%M:%S").replace(tzinfo=dt.timezone.utc)
|
||||
|
||||
|
||||
def extraire(source, fin, heures=24):
|
||||
stations, meta, journal = {}, {}, []
|
||||
sts, metas = source.get("stations", {}), source.get("metadonnees", {})
|
||||
debut = fin - dt.timedelta(hours=heures)
|
||||
for sid, ic in STATIONS.items():
|
||||
st, m = sts.get(ic, {}), metas.get(ic, {})
|
||||
rel = []
|
||||
for r in st.get("releves", []) if isinstance(st.get("releves"), list) else []:
|
||||
if not isinstance(r, dict) or not isinstance(r.get("dh_utc"), str) or r.get("temperature") is None:
|
||||
continue
|
||||
if lire_date(r["dh_utc"]) <= debut:
|
||||
continue
|
||||
rel.append({k: r[k] for k in CHAMPS_PUBLICS if r.get(k) is not None and k not in ("temperature_min", "temperature_max")})
|
||||
rel.sort(key=lambda r: r["dh_utc"])
|
||||
if rel:
|
||||
ts = [r["temperature"] for r in rel]
|
||||
rel[-1]["temperature_min"], rel[-1]["temperature_max"] = min(ts), max(ts)
|
||||
hors_ligne = not rel or fin - lire_date(rel[-1]["dh_utc"]) > dt.timedelta(minutes=HORS_LIGNE_MIN)
|
||||
source_st = "Station Gastinel" if ic == "VP2" else "Infoclimat"
|
||||
stations[sid] = {"nom": st.get("nom", sid), "source": source_st, "hors_ligne": hors_ligne, "releves": rel}
|
||||
meta[sid] = {"licence": m.get("licence") or ("" if ic == "VP2" else "Infoclimat")}
|
||||
journal.append("%s: %s (%d relevés)" % (sid, "hors ligne" if hors_ligne else "ok", len(rel)))
|
||||
obj = {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
|
||||
"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("--source", required=True)
|
||||
ap.add_argument("--sortie", default=SORTIE_DEFAUT)
|
||||
ap.add_argument("--heures", type=float, default=24.0)
|
||||
a = ap.parse_args(argv)
|
||||
source = charger_json(os.path.expanduser(a.source))
|
||||
if not source.get("stations"):
|
||||
print("source illisible ou vide : rien écrit")
|
||||
return 1
|
||||
obj, journal = extraire(source, maintenant(), a.heures)
|
||||
verifier_public(obj)
|
||||
ecrire_atomique(os.path.expanduser(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())
|
||||
@@ -0,0 +1,129 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Extrait les relevés de la VP2 de Lans (station Gastinel) des CSV du NVMe -> JSON public (public/data/vp2.json).
|
||||
|
||||
Source : /mnt/nvme/meteo-vp2/releves/AAAA-MM-JJ.csv (un relevé toutes les 20 s, copie en dur faite par archiver.sh).
|
||||
Lecture seule : ce script ne parle ni à weather-db ni à weather-collector. Sortie : un relevé toutes les 10 minutes.
|
||||
Seuls les champs extérieurs sortent : jamais la température ni l'humidité intérieures, la trame brute, la batterie.
|
||||
|
||||
Usage :
|
||||
python extraire_vp2.py --dossier /mnt/nvme/meteo-vp2/releves --sortie CHEMIN [--jours 2]
|
||||
"""
|
||||
import argparse
|
||||
import csv
|
||||
import datetime as dt
|
||||
import glob
|
||||
import math
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from collecter_weatherlink import ecrire_atomique, fmt_utc, maintenant, verifier_public # noqa: E402
|
||||
|
||||
SOURCE = "Station Gastinel (Davis Vantage Pro2)"
|
||||
PAS = 600
|
||||
HORS_LIGNE_MIN = 30
|
||||
POSITION = {"lat": 45.13, "lon": 5.60} # arrondie à 0,01 degré : pas l'emplacement exact
|
||||
|
||||
|
||||
def nombre(v):
|
||||
try:
|
||||
return float(v) if v not in ("", None) else None
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def point_de_rosee(t, h):
|
||||
"""Formule de Magnus (°C)."""
|
||||
if t is None or not h or h <= 0:
|
||||
return None
|
||||
g = math.log(h / 100.0) + 17.62 * t / (243.12 + t)
|
||||
return 243.12 * g / (17.62 - g)
|
||||
|
||||
|
||||
def lire_csv(chemins):
|
||||
"""Lignes (epoch, dict) triées, champs extérieurs seulement."""
|
||||
out = []
|
||||
for chemin in chemins:
|
||||
with open(chemin, encoding="utf-8", newline="") as f:
|
||||
for r in csv.DictReader(f):
|
||||
try:
|
||||
d = dt.datetime.strptime(r["utc"][:19], "%Y-%m-%dT%H:%M:%S").replace(tzinfo=dt.timezone.utc)
|
||||
except (ValueError, KeyError, TypeError):
|
||||
continue
|
||||
out.append((int(d.timestamp()), {
|
||||
"t": nombre(r.get("temp_ext_c")), "h": nombre(r.get("hum_ext")), "p": nombre(r.get("pression_hpa")),
|
||||
"v": nombre(r.get("vent_moy10_mps")), "dir": nombre(r.get("vent_dir")),
|
||||
"jour": nombre(r.get("pluie_jour_mm"))}))
|
||||
out.sort(key=lambda x: x[0])
|
||||
return out
|
||||
|
||||
|
||||
def releves(lignes, depuis=None):
|
||||
"""Un relevé par tranche de 10 minutes (le dernier de la tranche) ; pluie = écarts du cumul du jour."""
|
||||
tranches = {}
|
||||
for ts, v in lignes:
|
||||
tranches[ts // PAS * PAS] = v
|
||||
cles = sorted(tranches)
|
||||
out, pluie_tr, prec = [], [], None
|
||||
for ts in cles:
|
||||
v = tranches[ts]
|
||||
jour = v["jour"]
|
||||
if jour is not None and prec is not None:
|
||||
pluie_tr.append(max(0.0, jour - prec) if jour >= prec else jour) # remise à zéro à minuit
|
||||
else:
|
||||
pluie_tr.append(0.0)
|
||||
prec = jour if jour is not None else prec
|
||||
if depuis is not None and ts < depuis:
|
||||
continue
|
||||
if v["t"] is None:
|
||||
continue
|
||||
r = {"dh_utc": fmt_utc(dt.datetime.fromtimestamp(ts, dt.timezone.utc)), "temperature": round(v["t"], 1)}
|
||||
if v["h"] is not None:
|
||||
r["humidite"] = int(round(v["h"]))
|
||||
rosee = point_de_rosee(v["t"], v["h"])
|
||||
if rosee is not None:
|
||||
r["point_de_rosee"] = round(rosee, 1)
|
||||
if v["p"] is not None:
|
||||
r["pression"] = round(v["p"], 1)
|
||||
if v["v"] is not None:
|
||||
r["vent_moyen"] = round(v["v"] * 3.6, 1) # m/s -> km/h
|
||||
if v["dir"] is not None and v["v"] > 0:
|
||||
r["vent_direction"] = int(round(v["dir"])) % 360
|
||||
r["pluie_1h"] = round(sum(pluie_tr[-6:]), 1)
|
||||
if jour is not None:
|
||||
r["pluie_cumul_0h"] = round(jour, 1)
|
||||
out.append(r)
|
||||
if out:
|
||||
ts = [r["temperature"] for r in out[-144:]]
|
||||
out[-1]["temperature_min"], out[-1]["temperature_max"] = min(ts), max(ts)
|
||||
return out
|
||||
|
||||
|
||||
def construire(lignes, fin, jours=2):
|
||||
rel = releves(lignes, depuis=int(fin.timestamp()) - jours * 86400)
|
||||
dernier = dt.datetime.strptime(rel[-1]["dh_utc"], "%Y-%m-%d %H:%M:%S").replace(tzinfo=dt.timezone.utc) if rel else None
|
||||
hors = dernier is None or fin - dernier > dt.timedelta(minutes=HORS_LIGNE_MIN)
|
||||
obj = {"source": SOURCE, "mis_a_jour_utc": fin.strftime("%Y-%m-%dT%H:%M:%SZ"),
|
||||
"metadonnees": {"lans": dict(POSITION, licence="Station Gastinel (Davis Vantage Pro2)")},
|
||||
"stations": {"lans": {"nom": "Lans-en-Vercors – village", "source": "Station Gastinel", "hors_ligne": hors, "releves": rel}}}
|
||||
return obj
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
ap.add_argument("--dossier", required=True)
|
||||
ap.add_argument("--sortie", required=True)
|
||||
ap.add_argument("--jours", type=float, default=2.0)
|
||||
a = ap.parse_args(argv)
|
||||
fichiers = sorted(glob.glob(os.path.join(os.path.expanduser(a.dossier), "????-??-??.csv")))[-int(a.jours + 2):]
|
||||
fin = maintenant()
|
||||
obj = construire(lire_csv(fichiers), fin, a.jours)
|
||||
verifier_public(obj)
|
||||
ecrire_atomique(os.path.expanduser(a.sortie), obj)
|
||||
st = obj["stations"]["lans"]
|
||||
print("écrit : %s (%d relevés, %s)" % (os.path.basename(a.sortie), len(st["releves"]), "hors ligne" if st["hors_ligne"] else "en ligne"))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,79 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Importe l'historique horaire Météo-France (open data data.gouv.fr, « Données climatologiques de base - horaires »)
|
||||
des postes du Vercors dans la base d'archive de vercors.me (table `horaire`, un point par heure, jamais purgé).
|
||||
|
||||
Fichiers : H_<département>_<période>.csv.gz, séparateur « ; », déjà téléchargés dans un dossier.
|
||||
https://object.files.data.gouv.fr/meteofrance/data/synchro_ftp/BASE/HOR/H_38_latest-2025-2026.csv.gz (idem 26, et les décennies)
|
||||
Ce script ne télécharge rien. Licence Ouverte Etalab 2.0, source Météo-France.
|
||||
|
||||
Usage : python importer_opendata.py --db archive/vercors.db --dossier od/
|
||||
Les fichiers « latest » s'arrêtent plusieurs mois avant aujourd'hui : l'API temps réel (6 min) couvre les 5 derniers jours ;
|
||||
le trou entre les deux est à combler avec l'API climatologique (DPClim) si Théo s'y abonne.
|
||||
"""
|
||||
import argparse
|
||||
import csv
|
||||
import datetime as dt
|
||||
import glob
|
||||
import gzip
|
||||
import os
|
||||
import sqlite3
|
||||
import sys
|
||||
|
||||
POSTES = {"38021001": "autrans", "38548001": "villard", "26074001": "chapelle",
|
||||
"26290002": "rousset", "38186001": "gresse", "26307001": "st-jean"}
|
||||
# colonne de la base <- colonne Météo-France
|
||||
CHAMPS = (("t", "T"), ("tn", "TN"), ("tx", "TX"), ("td", "TD"), ("u", "U"), ("ff", "FF"), ("fxi", "FXI"),
|
||||
("dd", "DD"), ("rr1", "RR1"), ("pmer", "PMER"), ("neige", "NEIGETOT"))
|
||||
SCHEMA = """CREATE TABLE IF NOT EXISTS horaire (
|
||||
id TEXT NOT NULL, ts INTEGER NOT NULL,
|
||||
t REAL, tn REAL, tx REAL, td REAL, u REAL, ff REAL, fxi REAL, dd REAL, rr1 REAL, pmer REAL, neige REAL,
|
||||
PRIMARY KEY (id, ts)) WITHOUT ROWID"""
|
||||
|
||||
|
||||
def nombre(v):
|
||||
try:
|
||||
return float(v) if v not in ("", None) else None
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def epoch(aaaammjjhh):
|
||||
d = dt.datetime.strptime(aaaammjjhh, "%Y%m%d%H").replace(tzinfo=dt.timezone.utc)
|
||||
return int(d.timestamp())
|
||||
|
||||
|
||||
def importer_fichier(db, chemin):
|
||||
cols = [c for c, _ in CHAMPS]
|
||||
sql = ("INSERT OR REPLACE INTO horaire (id, ts, %s) VALUES (?, ?, %s)" % (", ".join(cols), ", ".join("?" * len(cols))))
|
||||
n = 0
|
||||
with gzip.open(chemin, "rt", encoding="utf-8") as f:
|
||||
for row in csv.DictReader(f, delimiter=";"):
|
||||
site = POSTES.get(row.get("NUM_POSTE"))
|
||||
if not site or not row.get("AAAAMMJJHH"):
|
||||
continue
|
||||
db.execute(sql, [site, epoch(row["AAAAMMJJHH"])] + [nombre(row.get(src)) for _, src in CHAMPS])
|
||||
n += 1
|
||||
db.commit()
|
||||
return n
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
ap.add_argument("--db", required=True)
|
||||
ap.add_argument("--dossier", required=True)
|
||||
a = ap.parse_args(argv)
|
||||
db = sqlite3.connect(os.path.expanduser(a.db))
|
||||
db.execute(SCHEMA)
|
||||
total = 0
|
||||
for chemin in sorted(glob.glob(os.path.join(os.path.expanduser(a.dossier), "H_*.csv.gz"))):
|
||||
n = importer_fichier(db, chemin)
|
||||
total += n
|
||||
print("%s : %d heures" % (os.path.basename(chemin), n))
|
||||
for site, mini, maxi, nb in db.execute("SELECT id, MIN(ts), MAX(ts), COUNT(*) FROM horaire GROUP BY id"):
|
||||
f = lambda t: dt.datetime.fromtimestamp(t, dt.timezone.utc).strftime("%Y-%m-%d")
|
||||
print(" %s : %d heures, du %s au %s" % (site, nb, f(mini), f(maxi)))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"_note": "Postes Météo-France du Vercors (API Package Observations v2, pas de 6 minutes). Aucune valeur secrète ici : seulement le NOM de la variable de la clé. L'identifiant Météo-France reste dans la config, il n'est pas écrit dans le JSON public.",
|
||||
"var_cle": "MF_DPPAQUETOBS_CLE",
|
||||
"fichier_env": "~/.config/meteo-vercors/meteofrance.env",
|
||||
"stations": {
|
||||
"mf-autrans": {"id": "38021001", "nom": "Autrans – L'Escandille", "lat": 45.182, "lon": 5.5522, "altitude": 1069},
|
||||
"mf-villard": {"id": "38548001", "nom": "Villard-de-Lans – Payonère", "lat": 45.0785, "lon": 5.561, "altitude": 1027},
|
||||
"mf-chapelle": {"id": "26074001", "nom": "La Chapelle-en-Vercors – Les Finets", "lat": 44.9615, "lon": 5.4222, "altitude": 879},
|
||||
"mf-rousset": {"id": "26290002", "nom": "Col du Rousset – plateau de Beurre", "lat": 44.8417, "lon": 5.4217, "altitude": 1400},
|
||||
"mf-gresse": {"id": "38186001", "nom": "Gresse-en-Vercors", "lat": 44.8998, "lon": 5.5657, "altitude": 1220},
|
||||
"mf-st-jean": {"id": "26307001", "nom": "Saint-Jean-en-Royans", "lat": 45.0092, "lon": 5.2925, "altitude": 308}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
# NON APPLIQUE. Version définitive du bloc Caddy de vercors.me (site-v2/ : carte en images, sans aucune ressource externe).
|
||||
# À activer APRÈS la page vide (vercors-me.caddy), quand Théo valide : copier site-v2/ vers /srv/vercors.me/.
|
||||
# Les JSON de données (data/*.json et data/semaine/) arrivent de cornafserver toutes les 6 min (voir 04-Infra-et-commandes.md).
|
||||
|
||||
www.vercors.me {
|
||||
redir https://vercors.me{uri} permanent
|
||||
}
|
||||
|
||||
vercors.me {
|
||||
import /etc/caddy/securite.caddy
|
||||
root * /srv/vercors.me
|
||||
encode zstd gzip
|
||||
|
||||
header {
|
||||
Referrer-Policy "strict-origin-when-cross-origin"
|
||||
Permissions-Policy "geolocation=(), camera=(), microphone=()"
|
||||
X-Frame-Options "DENY"
|
||||
Content-Security-Policy "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; font-src 'self'; connect-src 'self'; frame-ancestors 'none'"
|
||||
-Server
|
||||
}
|
||||
|
||||
# pages : /a-propos -> a-propos.html
|
||||
try_files {path} {path}.html {path}/index.html
|
||||
|
||||
@donnees path /data/*
|
||||
header @donnees Cache-Control "no-cache"
|
||||
@statique path /polices/* /tuiles/*
|
||||
header @statique Cache-Control "public, max-age=31536000, immutable"
|
||||
|
||||
file_server
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
*.sqlite3
|
||||
__pycache__/
|
||||
@@ -0,0 +1,69 @@
|
||||
# Forum de vercors.me (noyau local)
|
||||
|
||||
Forum où le père de Théo et d'autres adhérents météo publient (ex. « Récapitulatif de la semaine »). **État : noyau local, rien de déployé, rien de publié, authentification simulée.**
|
||||
|
||||
## Choix techniques
|
||||
- Python standard seulement (`http.server`, `sqlite3`, `unittest`) : comme `collecte/` du projet, aucune dépendance, facile à expliquer et à relire. Python 3.10 testé.
|
||||
- SQLite : un fichier, sauvegarde simple, suffisant pour un forum d'adhérents. À revoir si la charge explose (peu probable).
|
||||
- HTML généré côté serveur, sans JavaScript ni ressource distante, CSP stricte (`default-src 'none'`). Thème clair, coins carrés (`border-radius: 0`) pour cette maquette ; la DA finale est à caler sur le site vercors.me.
|
||||
- Tout texte utilisateur est échappé (`html.escape`). Les POST exigent une origine identique à l'hôte (anti-CSRF), le cookie est `HttpOnly; SameSite=Strict`.
|
||||
- Le serveur local n'écoute que sur `127.0.0.1`. Les journaux HTTP sont coupés (pas d'IP dans la sortie).
|
||||
|
||||
## Fichiers
|
||||
| Fichier | Rôle |
|
||||
|---|---|
|
||||
| `roles.py` | rôles, tableau des droits, `peut(role, droit)` |
|
||||
| `db.py` | schéma SQLite, catégories par défaut |
|
||||
| `forum.py` | logique : sujets, messages, signalements, masquage, rôles, purge IP ; tout contrôlé par les droits |
|
||||
| `server.py` | serveur HTTP local + pages + connexion simulée |
|
||||
| `tests/test_forum.py` | 18 tests (droits de chaque rôle, modération, HTTP, purge IP) |
|
||||
|
||||
Lancer : `python forum/server.py --seed` puis `http://127.0.0.1:8940/test-login?u=adherent1` (aussi `modo1`, `admin1` ; tout autre identifiant crée un « membre »). Tests : `python -I forum/tests/test_forum.py`.
|
||||
|
||||
## Modèle de données
|
||||
- `users` : `hub_id` (identifiant du compte Gastinel, unique), nom affiché, rôle (membre, adherent, moderateur, admin). Le visiteur n'a pas de ligne. Aucun e-mail ni mot de passe stocké : ils restent au Hub.
|
||||
- `categories` : slug, nom, rôle minimal pour créer un sujet. Par défaut : **Récapitulatif de la semaine**, Observations, Discussion générale (toutes réservées aux adhérents pour créer un sujet).
|
||||
- `topics` : catégorie, titre, auteur, `locked`, `hidden`.
|
||||
- `posts` : sujet, auteur, texte, `edited_at`, `hidden`, `ip` (purgeable).
|
||||
- `reports` : signalement d'un message (motif, un seul par personne et par message).
|
||||
- Prévu plus tard : table `attachments` (nom, type, taille, SHA-256, chemin) ; taille et types à limiter, stockage hors dossier web.
|
||||
|
||||
## Rôles et droits
|
||||
| Droit | Visiteur | Membre | Adhérent météo | Modérateur | Admin |
|
||||
|---|---|---|---|---|---|
|
||||
| Lire sujets et messages | oui | oui | oui | oui | oui |
|
||||
| Répondre (sujet non verrouillé) | non | oui | oui | oui | oui |
|
||||
| Modifier son propre message | non | oui | oui | oui | oui |
|
||||
| Signaler un message | non | oui | oui | oui | oui |
|
||||
| Créer un sujet (selon catégorie) | non | non | oui | oui | oui |
|
||||
| Masquer/afficher messages et sujets | non | non | non | oui | oui |
|
||||
| Verrouiller un sujet | non | non | non | oui | oui |
|
||||
| Voir les contenus masqués et les signalements | non | non | non | oui | oui |
|
||||
| Changer le rôle d'un utilisateur | non | non | non | non | oui |
|
||||
|
||||
Le visiteur est un navigateur sans compte. Un administrateur ne peut pas se rétrograder lui-même. L'attribution du rôle « adhérent » est faite par un administrateur (voir « À décider »).
|
||||
|
||||
## Modération
|
||||
- Un membre signale un message avec un motif ; les modérateurs voient la liste sur `/moderation`.
|
||||
- **Masquer** plutôt que supprimer : le contenu reste en base, invisible du public et du membre, visible des modérateurs, réversible. Pas de suppression définitive pour l'instant.
|
||||
- Verrouillage d'un sujet : plus de réponses.
|
||||
|
||||
## RGPD (à faire valider par Théo)
|
||||
- Données minimales : identifiant Hub, nom affiché, rôle, contenus publiés.
|
||||
- Adresse IP : enregistrée avec chaque message pour la personnalisation, **conservée 13 mois**, puis effacée par `Forum.purger_ips(13)` (testé). Il reste à planifier cette purge (tâche périodique) et à l'indiquer dans la politique de confidentialité.
|
||||
- Aucun usage des données hors du service lui-même (principe de Théo : pas d'entraînement, pas de publicité).
|
||||
- Suppression du compte Hub : à relier (anonymiser le nom affiché, garder ou retirer les messages : à décider).
|
||||
|
||||
## Intégration avec le Hub (Gastinel)
|
||||
État du Hub lu dans `5-infra/hub-comptes/docs/hub-comptes.md` : e-mail + mot de passe ou Google, jetons `Bearer` ou cookie `__Host-`, `GET /api/public/account` renvoie le compte (dont `email_verified`). « Se connecter avec Gastinel » (OpenID Connect fournisseur) est **prévu mais pas construit** ; aujourd'hui une appli peut utiliser `POST /api/public/auth/login` et le jeton `Bearer`. Je n'ai pas lu le code Go ni de secret.
|
||||
|
||||
Flux proposé (quand OIDC existera) : visiteur clique « Se connecter » -> redirection vers le Hub (code + PKCE) -> retour sur le forum avec le code -> le forum échange le code, lit l'identifiant du compte (`sub`) et le nom -> `Forum.utilisateur(sub, nom)` crée la ligne `users` (rôle membre) -> cookie de session du forum. Seul le point d'entrée `Handler.utilisateur()` de `server.py` change ; la logique et les droits restent identiques. Les rôles restent gérés dans le forum.
|
||||
|
||||
## À décider par Théo
|
||||
1. Hub : attendre OIDC fournisseur, ou utiliser tout de suite le jeton `Bearer` du Hub côté serveur ?
|
||||
2. Le forum exige-t-il une adresse e-mail vérifiée (`email_verified`) pour devenir membre ? Et le numéro vérifié ?
|
||||
3. Comment devient-on « adhérent météo » : attribution manuelle par un admin (proposé), liste fournie par l'association, ou demande dans le forum ?
|
||||
4. Les visiteurs voient-ils toutes les catégories ? Les membres peuvent-ils répondre dans « Récapitulatif » ?
|
||||
5. Pièces jointes : types, taille, stockage.
|
||||
6. Où l'héberger (VPS, Caddy, domaine `forum.vercors.me` ou `vercors.me/forum`) : aucun déploiement fait.
|
||||
7. Politique de suppression de compte et texte RGPD.
|
||||
@@ -0,0 +1,68 @@
|
||||
"""Schéma SQLite et accès aux données."""
|
||||
import sqlite3
|
||||
|
||||
SCHEMA = """
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id INTEGER PRIMARY KEY,
|
||||
hub_id TEXT NOT NULL UNIQUE, -- identifiant du compte Gastinel (Hub)
|
||||
display_name TEXT NOT NULL,
|
||||
role TEXT NOT NULL DEFAULT 'membre'
|
||||
CHECK (role IN ('membre','adherent','moderateur','admin')),
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS categories (
|
||||
id INTEGER PRIMARY KEY,
|
||||
slug TEXT NOT NULL UNIQUE,
|
||||
name TEXT NOT NULL,
|
||||
min_role_topic TEXT NOT NULL DEFAULT 'adherent',
|
||||
position INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS topics (
|
||||
id INTEGER PRIMARY KEY,
|
||||
category_id INTEGER NOT NULL REFERENCES categories(id),
|
||||
title TEXT NOT NULL,
|
||||
author_id INTEGER NOT NULL REFERENCES users(id),
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
locked INTEGER NOT NULL DEFAULT 0,
|
||||
hidden INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS posts (
|
||||
id INTEGER PRIMARY KEY,
|
||||
topic_id INTEGER NOT NULL REFERENCES topics(id),
|
||||
author_id INTEGER NOT NULL REFERENCES users(id),
|
||||
body TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
edited_at TEXT,
|
||||
hidden INTEGER NOT NULL DEFAULT 0,
|
||||
ip TEXT -- purgée après 13 mois (purger_ips)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS reports (
|
||||
id INTEGER PRIMARY KEY,
|
||||
post_id INTEGER NOT NULL REFERENCES posts(id),
|
||||
reporter_id INTEGER NOT NULL REFERENCES users(id),
|
||||
reason TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
UNIQUE (post_id, reporter_id)
|
||||
);
|
||||
-- Prévu plus tard : attachments(id, post_id, filename, mime, size, sha256, stored_path)
|
||||
CREATE INDEX IF NOT EXISTS idx_topics_cat ON topics(category_id, id DESC);
|
||||
CREATE INDEX IF NOT EXISTS idx_posts_topic ON posts(topic_id, id);
|
||||
"""
|
||||
|
||||
CATEGORIES_DEFAUT = [
|
||||
("recapitulatif-semaine", "Récapitulatif de la semaine", "adherent", 0),
|
||||
("observations", "Observations", "adherent", 1),
|
||||
("discussion", "Discussion générale", "adherent", 2),
|
||||
]
|
||||
|
||||
|
||||
def connecter(chemin=":memory:"):
|
||||
con = sqlite3.connect(chemin, check_same_thread=False)
|
||||
con.row_factory = sqlite3.Row
|
||||
con.execute("PRAGMA foreign_keys = ON")
|
||||
con.executescript(SCHEMA)
|
||||
for slug, nom, role, pos in CATEGORIES_DEFAUT:
|
||||
con.execute("INSERT OR IGNORE INTO categories(slug,name,min_role_topic,position)"
|
||||
" VALUES (?,?,?,?)", (slug, nom, role, pos))
|
||||
con.commit()
|
||||
return con
|
||||
@@ -0,0 +1,177 @@
|
||||
"""Logique du forum : toutes les actions passent par un contrôle de droits."""
|
||||
import db
|
||||
import roles
|
||||
|
||||
TITRE_MAX, CORPS_MAX = 150, 20000
|
||||
|
||||
|
||||
class Refus(Exception):
|
||||
"""Action interdite (rôle insuffisant, sujet verrouillé...)."""
|
||||
|
||||
|
||||
class Invalide(Exception):
|
||||
"""Données incorrectes ou objet introuvable."""
|
||||
|
||||
|
||||
class Forum:
|
||||
def __init__(self, chemin=":memory:"):
|
||||
self.con = db.connecter(chemin)
|
||||
|
||||
# --- utilisateurs -------------------------------------------------
|
||||
def utilisateur(self, hub_id, nom=None):
|
||||
"""Retourne l'utilisateur lié à ce compte Hub (créé 'membre' au besoin)."""
|
||||
r = self.con.execute("SELECT * FROM users WHERE hub_id=?", (hub_id,)).fetchone()
|
||||
if r is None:
|
||||
self.con.execute("INSERT INTO users(hub_id,display_name) VALUES (?,?)",
|
||||
(hub_id, (nom or hub_id)[:60]))
|
||||
self.con.commit()
|
||||
r = self.con.execute("SELECT * FROM users WHERE hub_id=?", (hub_id,)).fetchone()
|
||||
return r
|
||||
|
||||
@staticmethod
|
||||
def role_de(user):
|
||||
return roles.VISITEUR if user is None else user["role"]
|
||||
|
||||
def changer_role(self, acteur, hub_id, nouveau):
|
||||
if not roles.peut(self.role_de(acteur), "changer_role"):
|
||||
raise Refus("changer_role")
|
||||
if nouveau not in roles.ORDRE[1:]:
|
||||
raise Invalide("rôle inconnu")
|
||||
cible = self.con.execute("SELECT id FROM users WHERE hub_id=?", (hub_id,)).fetchone()
|
||||
if cible is None:
|
||||
raise Invalide("utilisateur inconnu")
|
||||
if cible["id"] == acteur["id"] and nouveau != roles.ADMIN:
|
||||
raise Refus("un administrateur ne se rétrograde pas lui-même")
|
||||
self.con.execute("UPDATE users SET role=? WHERE id=?", (nouveau, cible["id"]))
|
||||
self.con.commit()
|
||||
|
||||
# --- lecture ------------------------------------------------------
|
||||
def categories(self):
|
||||
return self.con.execute("SELECT * FROM categories ORDER BY position").fetchall()
|
||||
|
||||
def sujets(self, user, slug=None):
|
||||
voit = roles.peut(self.role_de(user), "voir_masques")
|
||||
sql = ("SELECT t.*, c.name AS cat_name, c.slug, u.display_name AS auteur,"
|
||||
" (SELECT COUNT(*) FROM posts p WHERE p.topic_id=t.id AND (p.hidden=0 OR ?)) AS n"
|
||||
" FROM topics t JOIN categories c ON c.id=t.category_id"
|
||||
" JOIN users u ON u.id=t.author_id WHERE (t.hidden=0 OR ?)")
|
||||
args = [int(voit), int(voit)]
|
||||
if slug:
|
||||
sql += " AND c.slug=?"
|
||||
args.append(slug)
|
||||
return self.con.execute(sql + " ORDER BY t.id DESC", args).fetchall()
|
||||
|
||||
def sujet(self, user, topic_id):
|
||||
"""Retourne (sujet, messages). Masqué = introuvable pour un non-modérateur."""
|
||||
voit = roles.peut(self.role_de(user), "voir_masques")
|
||||
t = self.con.execute(
|
||||
"SELECT t.*, c.name AS cat_name FROM topics t JOIN categories c"
|
||||
" ON c.id=t.category_id WHERE t.id=?", (topic_id,)).fetchone()
|
||||
if t is None or (t["hidden"] and not voit):
|
||||
raise Invalide("sujet introuvable")
|
||||
msgs = self.con.execute(
|
||||
"SELECT p.id,p.topic_id,p.author_id,p.body,p.created_at,p.edited_at,p.hidden,"
|
||||
" u.display_name AS auteur FROM posts p JOIN users u ON u.id=p.author_id"
|
||||
" WHERE p.topic_id=? AND (p.hidden=0 OR ?) ORDER BY p.id", (topic_id, int(voit))
|
||||
).fetchall()
|
||||
return t, msgs
|
||||
|
||||
# --- écriture -----------------------------------------------------
|
||||
@staticmethod
|
||||
def _texte(s, maxi, nom):
|
||||
s = (s or "").strip()
|
||||
if not s or len(s) > maxi:
|
||||
raise Invalide("%s vide ou trop long" % nom)
|
||||
return s
|
||||
|
||||
def creer_sujet(self, user, slug, titre, corps, ip=None):
|
||||
cat = self.con.execute("SELECT * FROM categories WHERE slug=?", (slug,)).fetchone()
|
||||
if cat is None:
|
||||
raise Invalide("catégorie inconnue")
|
||||
if not roles.peut(self.role_de(user), "creer_sujet", cat["min_role_topic"]):
|
||||
raise Refus("creer_sujet")
|
||||
titre = self._texte(titre, TITRE_MAX, "titre")
|
||||
corps = self._texte(corps, CORPS_MAX, "message")
|
||||
cur = self.con.execute("INSERT INTO topics(category_id,title,author_id) VALUES (?,?,?)",
|
||||
(cat["id"], titre, user["id"]))
|
||||
self.con.execute("INSERT INTO posts(topic_id,author_id,body,ip) VALUES (?,?,?,?)",
|
||||
(cur.lastrowid, user["id"], corps, ip))
|
||||
self.con.commit()
|
||||
return cur.lastrowid
|
||||
|
||||
def repondre(self, user, topic_id, corps, ip=None):
|
||||
if not roles.peut(self.role_de(user), "repondre"):
|
||||
raise Refus("repondre")
|
||||
t, _ = self.sujet(user, topic_id)
|
||||
if t["locked"]:
|
||||
raise Refus("sujet verrouillé")
|
||||
corps = self._texte(corps, CORPS_MAX, "message")
|
||||
cur = self.con.execute("INSERT INTO posts(topic_id,author_id,body,ip) VALUES (?,?,?,?)",
|
||||
(topic_id, user["id"], corps, ip))
|
||||
self.con.commit()
|
||||
return cur.lastrowid
|
||||
|
||||
def _post(self, post_id):
|
||||
p = self.con.execute("SELECT * FROM posts WHERE id=?", (post_id,)).fetchone()
|
||||
if p is None:
|
||||
raise Invalide("message introuvable")
|
||||
return p
|
||||
|
||||
def modifier_message(self, user, post_id, corps):
|
||||
if not roles.peut(self.role_de(user), "modifier_son_message"):
|
||||
raise Refus("modifier_son_message")
|
||||
p = self._post(post_id)
|
||||
if p["author_id"] != user["id"] or p["hidden"]:
|
||||
raise Refus("pas votre message")
|
||||
corps = self._texte(corps, CORPS_MAX, "message")
|
||||
self.con.execute("UPDATE posts SET body=?, edited_at=datetime('now') WHERE id=?",
|
||||
(corps, post_id))
|
||||
self.con.commit()
|
||||
|
||||
def signaler(self, user, post_id, motif):
|
||||
if not roles.peut(self.role_de(user), "signaler"):
|
||||
raise Refus("signaler")
|
||||
p = self._post(post_id)
|
||||
if p["hidden"]:
|
||||
raise Invalide("message introuvable")
|
||||
motif = self._texte(motif, 500, "motif")
|
||||
self.con.execute("INSERT OR IGNORE INTO reports(post_id,reporter_id,reason)"
|
||||
" VALUES (?,?,?)", (post_id, user["id"], motif))
|
||||
self.con.commit()
|
||||
|
||||
def signalements(self, user):
|
||||
if not roles.peut(self.role_de(user), "voir_signalements"):
|
||||
raise Refus("voir_signalements")
|
||||
return self.con.execute(
|
||||
"SELECT r.*, p.body, p.topic_id FROM reports r JOIN posts p ON p.id=r.post_id"
|
||||
" ORDER BY r.id DESC").fetchall()
|
||||
|
||||
def masquer_message(self, user, post_id, masque=True):
|
||||
if not roles.peut(self.role_de(user), "masquer"):
|
||||
raise Refus("masquer")
|
||||
self._post(post_id)
|
||||
self.con.execute("UPDATE posts SET hidden=? WHERE id=?", (int(masque), post_id))
|
||||
self.con.commit()
|
||||
|
||||
def masquer_sujet(self, user, topic_id, masque=True):
|
||||
if not roles.peut(self.role_de(user), "masquer"):
|
||||
raise Refus("masquer")
|
||||
self.sujet(user, topic_id)
|
||||
self.con.execute("UPDATE topics SET hidden=? WHERE id=?", (int(masque), topic_id))
|
||||
self.con.commit()
|
||||
|
||||
def verrouiller(self, user, topic_id, verrou=True):
|
||||
if not roles.peut(self.role_de(user), "verrouiller"):
|
||||
raise Refus("verrouiller")
|
||||
self.sujet(user, topic_id)
|
||||
self.con.execute("UPDATE topics SET locked=? WHERE id=?", (int(verrou), topic_id))
|
||||
self.con.commit()
|
||||
|
||||
# --- RGPD ---------------------------------------------------------
|
||||
def purger_ips(self, mois=13):
|
||||
"""Efface les adresses IP de plus de `mois` mois. Retourne le nombre de lignes."""
|
||||
cur = self.con.execute(
|
||||
"UPDATE posts SET ip=NULL WHERE ip IS NOT NULL"
|
||||
" AND created_at < datetime('now', ?)", ("-%d months" % mois,))
|
||||
self.con.commit()
|
||||
return cur.rowcount
|
||||
@@ -0,0 +1,33 @@
|
||||
"""Rôles et droits du forum. Aucune dépendance."""
|
||||
|
||||
VISITEUR, MEMBRE, ADHERENT, MODERATEUR, ADMIN = (
|
||||
"visiteur", "membre", "adherent", "moderateur", "admin")
|
||||
ORDRE = [VISITEUR, MEMBRE, ADHERENT, MODERATEUR, ADMIN]
|
||||
|
||||
# Droit -> rôle minimal
|
||||
DROITS = {
|
||||
"lire": VISITEUR,
|
||||
"repondre": MEMBRE,
|
||||
"signaler": MEMBRE,
|
||||
"modifier_son_message": MEMBRE,
|
||||
"creer_sujet": ADHERENT, # peut être relevé par catégorie (voir db)
|
||||
"masquer": MODERATEUR,
|
||||
"verrouiller": MODERATEUR,
|
||||
"voir_masques": MODERATEUR,
|
||||
"voir_signalements": MODERATEUR,
|
||||
"changer_role": ADMIN,
|
||||
"gerer_categories": ADMIN,
|
||||
}
|
||||
|
||||
|
||||
def niveau(role):
|
||||
if role not in ORDRE:
|
||||
raise ValueError("rôle inconnu : %r" % (role,))
|
||||
return ORDRE.index(role)
|
||||
|
||||
|
||||
def peut(role, droit, role_min=None):
|
||||
"""Vrai si `role` a `droit`. `role_min` remplace le minimum par défaut."""
|
||||
if droit not in DROITS:
|
||||
raise ValueError("droit inconnu : %r" % (droit,))
|
||||
return niveau(role) >= niveau(role_min or DROITS[droit])
|
||||
@@ -0,0 +1,281 @@
|
||||
"""Serveur HTTP local du forum (http.server, aucune dépendance).
|
||||
|
||||
AUTHENTIFICATION SIMULÉE : le cookie `forum_test` contient un identifiant Hub fictif.
|
||||
Elle sera remplacée par la connexion au Hub. À ne jamais exposer sur Internet :
|
||||
le serveur n'écoute que sur 127.0.0.1.
|
||||
|
||||
Lancer : python forum/server.py --seed (puis http://127.0.0.1:8940/)
|
||||
"""
|
||||
import argparse
|
||||
import html
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from http import cookies
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
import roles # noqa: E402
|
||||
from forum import Forum, Invalide, Refus # noqa: E402
|
||||
|
||||
COOKIE = "forum_test"
|
||||
ID_OK = re.compile(r"^[A-Za-z0-9_.-]{1,40}$")
|
||||
|
||||
CSS = """
|
||||
:root{color-scheme:light}
|
||||
*{border-radius:0!important;box-sizing:border-box}
|
||||
body{margin:0;font:16px/1.5 Inter,system-ui,sans-serif;background:#fff;color:#111}
|
||||
main{max-width:760px;margin:0 auto;padding:32px 16px}
|
||||
header{border-bottom:1px solid #111;padding:12px 16px;display:flex;gap:16px;
|
||||
justify-content:space-between;flex-wrap:wrap}
|
||||
a{color:#111}h1{font-size:1.5rem;margin:0 0 24px}h2{font-size:1.1rem;margin:32px 0 8px}
|
||||
ul{list-style:none;padding:0;margin:0}li{border-bottom:1px solid #ddd;padding:10px 0}
|
||||
small,.meta{color:#555}
|
||||
.post{border:1px solid #111;padding:12px 16px;margin:12px 0}.post.cache{border-style:dashed}
|
||||
form{margin:16px 0}label{display:block;margin:8px 0 2px}
|
||||
input,select,textarea,button{font:inherit;border:1px solid #111;padding:6px 8px;background:#fff;color:#111}
|
||||
textarea{width:100%;min-height:120px}input[type=text]{width:100%}
|
||||
button{cursor:pointer}button:hover{background:#111;color:#fff}
|
||||
.bandeau{border:1px solid #111;padding:8px 12px;margin-bottom:24px}
|
||||
form.inline{display:inline;margin:0}
|
||||
"""
|
||||
|
||||
|
||||
def e(s):
|
||||
return html.escape(str(s), quote=True)
|
||||
|
||||
|
||||
class App:
|
||||
def __init__(self, forum):
|
||||
self.forum = forum
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
server_version = "ForumLocal"
|
||||
app = None # défini dans creer_serveur
|
||||
|
||||
def log_message(self, *a): # pas de journal d'IP/URL sur la sortie
|
||||
pass
|
||||
|
||||
# --- outils -------------------------------------------------------
|
||||
def utilisateur(self):
|
||||
c = cookies.SimpleCookie(self.headers.get("Cookie", ""))
|
||||
if COOKIE in c and ID_OK.match(c[COOKIE].value):
|
||||
return self.app.forum.utilisateur(c[COOKIE].value)
|
||||
return None
|
||||
|
||||
def envoyer(self, code, corps, extra=()):
|
||||
data = corps.encode("utf-8")
|
||||
self.send_response(code)
|
||||
self.send_header("Content-Type", "text/html; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(data)))
|
||||
self.send_header("Content-Security-Policy",
|
||||
"default-src 'none'; style-src 'unsafe-inline'; form-action 'self'")
|
||||
self.send_header("X-Content-Type-Options", "nosniff")
|
||||
for k, v in extra:
|
||||
self.send_header(k, v)
|
||||
self.end_headers()
|
||||
self.wfile.write(data)
|
||||
|
||||
def rediriger(self, url, extra=()):
|
||||
self.send_response(303)
|
||||
self.send_header("Location", url)
|
||||
for k, v in extra:
|
||||
self.send_header(k, v)
|
||||
self.send_header("Content-Length", "0")
|
||||
self.end_headers()
|
||||
|
||||
def page(self, titre, contenu, user, code=200):
|
||||
if user is None:
|
||||
qui = "Visiteur (lecture seule)"
|
||||
else:
|
||||
qui = "%s - %s" % (e(user["display_name"]), e(user["role"]))
|
||||
corps = ("<!doctype html><html lang='fr'><meta charset='utf-8'>"
|
||||
"<meta name='viewport' content='width=device-width,initial-scale=1'>"
|
||||
"<title>%s - Forum Vercors</title><style>%s</style>"
|
||||
"<header><a href='/'>Forum Vercors</a><span>%s</span>"
|
||||
"<a href='/moderation'>Modération</a></header><main>"
|
||||
"<div class='bandeau'>Connexion simulée (test local). "
|
||||
"Sera remplacée par le compte Gastinel.</div>%s</main></html>"
|
||||
% (e(titre), CSS, qui, contenu))
|
||||
self.envoyer(code, corps)
|
||||
|
||||
def erreur(self, user, code, msg):
|
||||
self.page("Erreur", "<h1>%s</h1><p><a href='/'>Retour</a></p>" % e(msg), user, code)
|
||||
|
||||
def origine_ok(self):
|
||||
o = self.headers.get("Origin") or self.headers.get("Referer") or ""
|
||||
return urlparse(o).netloc == self.headers.get("Host", "x")
|
||||
|
||||
# --- GET ----------------------------------------------------------
|
||||
def do_GET(self):
|
||||
u = urlparse(self.path)
|
||||
user = self.utilisateur()
|
||||
f = self.app.forum
|
||||
try:
|
||||
if u.path == "/test-login":
|
||||
qui = parse_qs(u.query).get("u", [""])[0]
|
||||
if not ID_OK.match(qui):
|
||||
return self.erreur(user, 400, "Identifiant de test invalide")
|
||||
f.utilisateur(qui)
|
||||
return self.rediriger("/", [("Set-Cookie", "%s=%s; Path=/; HttpOnly; "
|
||||
"SameSite=Strict" % (COOKIE, qui))])
|
||||
if u.path == "/test-logout":
|
||||
return self.rediriger("/", [("Set-Cookie", COOKIE + "=; Path=/; Max-Age=0")])
|
||||
if u.path == "/":
|
||||
return self.liste(user, None)
|
||||
m = re.fullmatch(r"/c/([a-z0-9-]+)", u.path)
|
||||
if m:
|
||||
return self.liste(user, m.group(1))
|
||||
m = re.fullmatch(r"/t/(\d+)", u.path)
|
||||
if m:
|
||||
return self.sujet(user, int(m.group(1)))
|
||||
if u.path == "/moderation":
|
||||
return self.moderation(user)
|
||||
self.erreur(user, 404, "Page introuvable")
|
||||
except Refus:
|
||||
self.erreur(user, 403, "Action non autorisée pour votre rôle")
|
||||
except Invalide as ex:
|
||||
self.erreur(user, 404, str(ex))
|
||||
|
||||
def liste(self, user, slug):
|
||||
f = self.app.forum
|
||||
role = f.role_de(user)
|
||||
cats = f.categories()
|
||||
nav = " | ".join("<a href='/c/%s'>%s</a>" % (c["slug"], e(c["name"])) for c in cats)
|
||||
items = "".join(
|
||||
"<li><a href='/t/%d'>%s</a>%s<br><small>%s - %s - %d message(s)</small></li>"
|
||||
% (t["id"], e(t["title"]), " (masqué)" if t["hidden"] else "",
|
||||
e(t["cat_name"]), e(t["auteur"]), t["n"]) for t in f.sujets(user, slug))
|
||||
formulaire = ""
|
||||
possibles = [c for c in cats if roles.peut(role, "creer_sujet", c["min_role_topic"])]
|
||||
if possibles:
|
||||
opts = "".join("<option value='%s'%s>%s</option>" % (
|
||||
c["slug"], " selected" if c["slug"] == slug else "", e(c["name"]))
|
||||
for c in possibles)
|
||||
formulaire = ("<h2>Nouveau sujet</h2><form method='post' action='/sujet'>"
|
||||
"<label>Catégorie</label><select name='categorie'>%s</select>"
|
||||
"<label>Titre</label><input type='text' name='titre' maxlength='150' required>"
|
||||
"<label>Message</label><textarea name='corps' required></textarea>"
|
||||
"<button>Publier</button></form>" % opts)
|
||||
elif user is not None:
|
||||
formulaire = "<p class='meta'>Seuls les adhérents météo publient des sujets.</p>"
|
||||
else:
|
||||
formulaire = "<p class='meta'>Connectez-vous pour participer.</p>"
|
||||
self.page("Sujets", "<h1>Sujets</h1><p>%s</p><ul>%s</ul>%s"
|
||||
% (nav, items or "<li>Aucun sujet.</li>", formulaire), user)
|
||||
|
||||
def sujet(self, user, tid):
|
||||
f = self.app.forum
|
||||
role = f.role_de(user)
|
||||
t, msgs = f.sujet(user, tid)
|
||||
modo = roles.peut(role, "masquer")
|
||||
out = ["<h1>%s</h1><p class='meta'>%s%s%s</p>" % (
|
||||
e(t["title"]), e(t["cat_name"]), " - verrouillé" if t["locked"] else "",
|
||||
" - masqué" if t["hidden"] else "")]
|
||||
for p in msgs:
|
||||
actions = ""
|
||||
if roles.peut(role, "signaler"):
|
||||
actions += ("<form class='inline' method='post' action='/signaler'>"
|
||||
"<input type='hidden' name='post' value='%d'>"
|
||||
"<input name='motif' placeholder='Motif' required>"
|
||||
"<button>Signaler</button></form> " % p["id"])
|
||||
if modo:
|
||||
actions += ("<form class='inline' method='post' action='/masquer'>"
|
||||
"<input type='hidden' name='post' value='%d'>"
|
||||
"<input type='hidden' name='etat' value='%d'>"
|
||||
"<button>%s</button></form>"
|
||||
% (p["id"], 0 if p["hidden"] else 1,
|
||||
"Afficher" if p["hidden"] else "Masquer"))
|
||||
out.append("<div class='post%s'><p class='meta'>%s - %s</p><div>%s</div>%s</div>" % (
|
||||
" cache" if p["hidden"] else "", e(p["auteur"]), e(p["created_at"]),
|
||||
e(p["body"]).replace("\n", "<br>"), actions))
|
||||
if roles.peut(role, "verrouiller"):
|
||||
out.append("<form method='post' action='/verrouiller'>"
|
||||
"<input type='hidden' name='sujet' value='%d'>"
|
||||
"<input type='hidden' name='etat' value='%d'><button>%s</button></form>"
|
||||
% (tid, 0 if t["locked"] else 1,
|
||||
"Déverrouiller" if t["locked"] else "Verrouiller"))
|
||||
if roles.peut(role, "repondre") and not t["locked"]:
|
||||
out.append("<h2>Répondre</h2><form method='post' action='/repondre'>"
|
||||
"<input type='hidden' name='sujet' value='%d'>"
|
||||
"<textarea name='corps' required></textarea><button>Envoyer</button></form>"
|
||||
% tid)
|
||||
elif user is None:
|
||||
out.append("<p class='meta'>Connectez-vous pour répondre.</p>")
|
||||
self.page(t["title"], "".join(out), user)
|
||||
|
||||
def moderation(self, user):
|
||||
s = self.app.forum.signalements(user)
|
||||
items = "".join("<li>Message %d (sujet <a href='/t/%d'>%d</a>) : %s<br><small>%s</small></li>"
|
||||
% (r["post_id"], r["topic_id"], r["topic_id"], e(r["reason"]),
|
||||
e(r["body"][:200])) for r in s)
|
||||
self.page("Modération", "<h1>Signalements</h1><ul>%s</ul>"
|
||||
% (items or "<li>Aucun signalement.</li>"), user)
|
||||
|
||||
# --- POST ---------------------------------------------------------
|
||||
def do_POST(self):
|
||||
user = self.utilisateur()
|
||||
f = self.app.forum
|
||||
if not self.origine_ok():
|
||||
return self.erreur(user, 403, "Origine refusée")
|
||||
n = min(int(self.headers.get("Content-Length") or 0), 100000)
|
||||
d = {k: v[0] for k, v in parse_qs(self.rfile.read(n).decode("utf-8", "replace")).items()}
|
||||
ip = self.client_address[0]
|
||||
try:
|
||||
if user is None:
|
||||
raise Refus("connexion requise")
|
||||
if self.path == "/sujet":
|
||||
tid = f.creer_sujet(user, d.get("categorie", ""), d.get("titre"), d.get("corps"), ip)
|
||||
return self.rediriger("/t/%d" % tid)
|
||||
if self.path == "/repondre":
|
||||
tid = int(d.get("sujet", "0"))
|
||||
f.repondre(user, tid, d.get("corps"), ip)
|
||||
return self.rediriger("/t/%d" % tid)
|
||||
if self.path == "/signaler":
|
||||
f.signaler(user, int(d.get("post", "0")), d.get("motif"))
|
||||
return self.rediriger("/")
|
||||
if self.path == "/masquer":
|
||||
f.masquer_message(user, int(d.get("post", "0")), d.get("etat") == "1")
|
||||
return self.rediriger(self.headers.get("Referer") or "/")
|
||||
if self.path == "/verrouiller":
|
||||
tid = int(d.get("sujet", "0"))
|
||||
f.verrouiller(user, tid, d.get("etat") == "1")
|
||||
return self.rediriger("/t/%d" % tid)
|
||||
if self.path == "/role":
|
||||
f.changer_role(user, d.get("hub_id", ""), d.get("role", ""))
|
||||
return self.rediriger("/")
|
||||
self.erreur(user, 404, "Page introuvable")
|
||||
except Refus:
|
||||
self.erreur(user, 403, "Action non autorisée pour votre rôle")
|
||||
except (Invalide, ValueError) as ex:
|
||||
self.erreur(user, 400, str(ex))
|
||||
|
||||
|
||||
def creer_serveur(forum, port=0, hote="127.0.0.1"):
|
||||
h = type("H", (Handler,), {"app": App(forum)})
|
||||
return ThreadingHTTPServer((hote, port), h)
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--db", default=os.path.join(os.path.dirname(os.path.abspath(__file__)),
|
||||
"forum-local.sqlite3"))
|
||||
ap.add_argument("--port", type=int, default=8940)
|
||||
ap.add_argument("--seed", action="store_true",
|
||||
help="crée des comptes de test : adherent1, modo1, admin1")
|
||||
a = ap.parse_args()
|
||||
f = Forum(a.db)
|
||||
if a.seed:
|
||||
for hub_id, r in (("adherent1", "adherent"), ("modo1", "moderateur"), ("admin1", "admin")):
|
||||
f.utilisateur(hub_id)
|
||||
f.con.execute("UPDATE users SET role=? WHERE hub_id=?", (r, hub_id))
|
||||
f.con.commit()
|
||||
s = creer_serveur(f, a.port)
|
||||
print("Forum local (auth SIMULÉE) : http://127.0.0.1:%d/ (ex. /test-login?u=adherent1)" % a.port)
|
||||
s.serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,248 @@
|
||||
"""Tests du forum. Lancer : python -I forum/tests/test_forum.py"""
|
||||
import http.client
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from urllib.parse import urlencode
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
|
||||
import roles # noqa: E402
|
||||
import server # noqa: E402
|
||||
from forum import Forum, Invalide, Refus # noqa: E402
|
||||
|
||||
RECAP = "recapitulatif-semaine"
|
||||
|
||||
|
||||
def faire():
|
||||
f = Forum()
|
||||
u = {"membre": f.utilisateur("m1")}
|
||||
for hub, r in (("a1", "adherent"), ("mo1", "moderateur"), ("ad1", "admin")):
|
||||
u[r] = f.utilisateur(hub)
|
||||
f.con.execute("UPDATE users SET role=? WHERE hub_id=?", (r, hub))
|
||||
f.con.commit()
|
||||
u = {r: f.utilisateur(x["hub_id"]) for r, x in u.items()}
|
||||
u["visiteur"] = None
|
||||
return f, u
|
||||
|
||||
|
||||
class TestRoles(unittest.TestCase):
|
||||
def test_tableau_des_droits(self):
|
||||
attendu = {
|
||||
"lire": [1, 1, 1, 1, 1],
|
||||
"repondre": [0, 1, 1, 1, 1],
|
||||
"signaler": [0, 1, 1, 1, 1],
|
||||
"creer_sujet": [0, 0, 1, 1, 1],
|
||||
"masquer": [0, 0, 0, 1, 1],
|
||||
"verrouiller": [0, 0, 0, 1, 1],
|
||||
"voir_signalements": [0, 0, 0, 1, 1],
|
||||
"changer_role": [0, 0, 0, 0, 1],
|
||||
}
|
||||
for droit, lignes in attendu.items():
|
||||
for r, ok in zip(roles.ORDRE, lignes):
|
||||
self.assertEqual(roles.peut(r, droit), bool(ok), (droit, r))
|
||||
|
||||
def test_inconnus(self):
|
||||
with self.assertRaises(ValueError):
|
||||
roles.peut("roi", "lire")
|
||||
with self.assertRaises(ValueError):
|
||||
roles.peut("membre", "tout")
|
||||
|
||||
|
||||
class TestForum(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.f, self.u = faire()
|
||||
|
||||
def test_visiteur_lit_mais_ne_cree_pas(self):
|
||||
t = self.f.creer_sujet(self.u["adherent"], RECAP, "Semaine 44", "Pluie.")
|
||||
self.assertEqual(len(self.f.sujets(None)), 1)
|
||||
self.assertEqual(len(self.f.sujet(None, t)[1]), 1)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.creer_sujet(None, RECAP, "x", "y")
|
||||
with self.assertRaises(Refus):
|
||||
self.f.repondre(None, t, "x")
|
||||
with self.assertRaises(Refus):
|
||||
self.f.signaler(None, 1, "x")
|
||||
|
||||
def test_membre_repond_mais_ne_publie_pas(self):
|
||||
with self.assertRaises(Refus):
|
||||
self.f.creer_sujet(self.u["membre"], RECAP, "x", "y")
|
||||
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Vent")
|
||||
self.f.repondre(self.u["membre"], t, "Merci")
|
||||
self.assertEqual(len(self.f.sujet(None, t)[1]), 2)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.masquer_message(self.u["membre"], 1)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.verrouiller(self.u["membre"], t)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.signalements(self.u["membre"])
|
||||
|
||||
def test_adherent_publie_recap(self):
|
||||
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte", ip="1.2.3.4")
|
||||
s, m = self.f.sujet(None, t)
|
||||
self.assertEqual(s["cat_name"], "Récapitulatif de la semaine")
|
||||
self.assertEqual(m[0]["auteur"], "a1")
|
||||
with self.assertRaises(Refus):
|
||||
self.f.masquer_sujet(self.u["adherent"], t)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.changer_role(self.u["adherent"], "m1", "admin")
|
||||
|
||||
def test_modifier_seulement_son_message(self):
|
||||
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte")
|
||||
p = self.f.repondre(self.u["membre"], t, "a")
|
||||
self.f.modifier_message(self.u["membre"], p, "b")
|
||||
self.assertEqual(self.f.sujet(None, t)[1][1]["body"], "b")
|
||||
with self.assertRaises(Refus):
|
||||
self.f.modifier_message(self.u["adherent"], p, "pirate")
|
||||
with self.assertRaises(Refus):
|
||||
self.f.modifier_message(None, p, "pirate")
|
||||
|
||||
def test_moderation_masquage_et_signalement(self):
|
||||
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte")
|
||||
p = self.f.repondre(self.u["membre"], t, "spam")
|
||||
self.f.signaler(self.u["adherent"], p, "publicité")
|
||||
self.f.signaler(self.u["adherent"], p, "publicité") # doublon ignoré
|
||||
sig = self.f.signalements(self.u["moderateur"])
|
||||
self.assertEqual(len(sig), 1)
|
||||
self.f.masquer_message(self.u["moderateur"], p)
|
||||
self.assertEqual(len(self.f.sujet(None, t)[1]), 1) # invisible au public
|
||||
self.assertEqual(len(self.f.sujet(self.u["membre"], t)[1]), 1)
|
||||
self.assertEqual(len(self.f.sujet(self.u["moderateur"], t)[1]), 2)
|
||||
self.f.masquer_message(self.u["moderateur"], p, False)
|
||||
self.assertEqual(len(self.f.sujet(None, t)[1]), 2)
|
||||
|
||||
def test_sujet_masque_et_verrouille(self):
|
||||
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte")
|
||||
self.f.verrouiller(self.u["moderateur"], t)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.repondre(self.u["membre"], t, "x")
|
||||
self.f.verrouiller(self.u["moderateur"], t, False)
|
||||
self.f.masquer_sujet(self.u["moderateur"], t)
|
||||
self.assertEqual(self.f.sujets(None), [])
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.sujet(None, t)
|
||||
self.assertEqual(len(self.f.sujets(self.u["moderateur"])), 1)
|
||||
|
||||
def test_admin_change_les_roles(self):
|
||||
self.f.changer_role(self.u["admin"], "m1", "adherent")
|
||||
m = self.f.utilisateur("m1")
|
||||
self.f.creer_sujet(m, RECAP, "ok", "ok")
|
||||
with self.assertRaises(Refus):
|
||||
self.f.changer_role(self.u["moderateur"], "m1", "membre")
|
||||
with self.assertRaises(Refus):
|
||||
self.f.changer_role(self.u["admin"], "ad1", "membre") # pas d'auto-rétrogradation
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.changer_role(self.u["admin"], "m1", "visiteur")
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.changer_role(self.u["admin"], "inconnu", "membre")
|
||||
|
||||
def test_validation_des_champs(self):
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.creer_sujet(self.u["adherent"], RECAP, " ", "x")
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.creer_sujet(self.u["adherent"], "nope", "t", "x")
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.creer_sujet(self.u["adherent"], RECAP, "t" * 200, "x")
|
||||
|
||||
def test_purge_ip_13_mois(self):
|
||||
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte", ip="1.2.3.4")
|
||||
self.f.repondre(self.u["membre"], t, "récent", ip="5.6.7.8")
|
||||
self.f.con.execute("UPDATE posts SET created_at=datetime('now','-14 months') WHERE id=1")
|
||||
self.f.con.commit()
|
||||
self.assertEqual(self.f.purger_ips(13), 1)
|
||||
ips = [r["ip"] for r in self.f.con.execute("SELECT ip FROM posts ORDER BY id")]
|
||||
self.assertEqual(ips, [None, "5.6.7.8"])
|
||||
|
||||
|
||||
class TestHTTP(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.f, cls.u = faire()
|
||||
cls.srv = server.creer_serveur(cls.f)
|
||||
cls.port = cls.srv.server_address[1]
|
||||
threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.srv.shutdown()
|
||||
cls.srv.server_close()
|
||||
|
||||
def req(self, methode, chemin, user=None, data=None, origine=True):
|
||||
c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=5)
|
||||
h = {}
|
||||
if user:
|
||||
h["Cookie"] = "%s=%s" % (server.COOKIE, user)
|
||||
body = None
|
||||
if data is not None:
|
||||
body = urlencode(data)
|
||||
h["Content-Type"] = "application/x-www-form-urlencoded"
|
||||
if origine:
|
||||
h["Origin"] = "http://127.0.0.1:%d" % self.port
|
||||
c.request(methode, chemin, body, h)
|
||||
r = c.getresponse()
|
||||
txt = r.read().decode("utf-8")
|
||||
c.close()
|
||||
return r, txt
|
||||
|
||||
def test_visiteur_lit_sans_formulaire(self):
|
||||
r, txt = self.req("GET", "/")
|
||||
self.assertEqual(r.status, 200)
|
||||
self.assertIn("lecture seule", txt)
|
||||
self.assertNotIn("Nouveau sujet", txt)
|
||||
self.assertIn("light", txt)
|
||||
self.assertNotIn("http://", txt.replace("http://127.0.0.1", "")) # aucune ressource distante
|
||||
self.assertIn("default-src 'none'", r.getheader("Content-Security-Policy"))
|
||||
|
||||
def test_membre_ne_peut_pas_publier(self):
|
||||
r, txt = self.req("GET", "/", "m1")
|
||||
self.assertNotIn("Nouveau sujet", txt)
|
||||
r, _ = self.req("POST", "/sujet", "m1",
|
||||
{"categorie": RECAP, "titre": "x", "corps": "y"})
|
||||
self.assertEqual(r.status, 403)
|
||||
|
||||
def test_adherent_publie_et_echappement(self):
|
||||
r, txt = self.req("GET", "/", "a1")
|
||||
self.assertIn("Nouveau sujet", txt)
|
||||
r, _ = self.req("POST", "/sujet", "a1", {
|
||||
"categorie": RECAP, "titre": "Semaine <b>44</b>", "corps": "<script>x()</script>"})
|
||||
self.assertEqual(r.status, 303)
|
||||
r, txt = self.req("GET", r.getheader("Location"))
|
||||
self.assertEqual(r.status, 200)
|
||||
self.assertIn("<script>", txt)
|
||||
self.assertNotIn("<script>", txt)
|
||||
self.assertNotIn("<b>44", txt)
|
||||
|
||||
def test_post_sans_connexion_ou_sans_origine(self):
|
||||
r, _ = self.req("POST", "/sujet", None, {"categorie": RECAP, "titre": "x", "corps": "y"})
|
||||
self.assertEqual(r.status, 403)
|
||||
r, _ = self.req("POST", "/sujet", "a1",
|
||||
{"categorie": RECAP, "titre": "x", "corps": "y"}, origine=False)
|
||||
self.assertEqual(r.status, 403)
|
||||
|
||||
def test_moderation_reservee(self):
|
||||
self.assertEqual(self.req("GET", "/moderation")[0].status, 403)
|
||||
self.assertEqual(self.req("GET", "/moderation", "m1")[0].status, 403)
|
||||
self.assertEqual(self.req("GET", "/moderation", "a1")[0].status, 403)
|
||||
self.assertEqual(self.req("GET", "/moderation", "mo1")[0].status, 200)
|
||||
self.assertEqual(self.req("GET", "/moderation", "ad1")[0].status, 200)
|
||||
|
||||
def test_masquage_http(self):
|
||||
tid = self.f.creer_sujet(self.u["adherent"], RECAP, "S45", "Texte")
|
||||
pid = self.f.repondre(self.u["membre"], tid, "contenu-douteux")
|
||||
r, _ = self.req("POST", "/masquer", "m1", {"post": pid, "etat": "1"})
|
||||
self.assertEqual(r.status, 403)
|
||||
r, _ = self.req("POST", "/masquer", "mo1", {"post": pid, "etat": "1"})
|
||||
self.assertEqual(r.status, 303)
|
||||
self.assertNotIn("contenu-douteux", self.req("GET", "/t/%d" % tid)[1])
|
||||
self.assertIn("contenu-douteux", self.req("GET", "/t/%d" % tid, "mo1")[1])
|
||||
|
||||
def test_login_test_cookie(self):
|
||||
r, _ = self.req("GET", "/test-login?u=a1")
|
||||
self.assertEqual(r.status, 303)
|
||||
self.assertIn("HttpOnly", r.getheader("Set-Cookie"))
|
||||
self.assertEqual(self.req("GET", "/test-login?u=../x")[0].status, 400)
|
||||
self.assertEqual(self.req("GET", "/t/99999")[0].status, 404)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(verbosity=2)
|
||||
@@ -0,0 +1,75 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<title>À propos · Météo Vercors</title>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(polices/bitter-italic.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Bitter';font-style:normal;font-weight:500 700;font-display:swap;src:url(polices/bitter-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Outfit';font-style:normal;font-weight:400 600;font-display:swap;src:url(polices/outfit-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
:root{--titre:'Bitter',Georgia,serif;--texte:'Outfit',system-ui,sans-serif;--sapin:#1f4d3a;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--gris:#5d635e}
|
||||
*{box-sizing:border-box}
|
||||
html,body{margin:0;background:var(--calcaire);color:var(--roche);font-family:var(--texte);line-height:1.55}
|
||||
a{color:var(--sapin)}
|
||||
a:focus-visible,button:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
.haut{max-width:760px;margin:0 auto;padding:26px 20px 0}
|
||||
.retour{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.12em;text-transform:uppercase;text-decoration:none;color:#fff;background:var(--sapin);padding:8px 12px}
|
||||
main{max-width:760px;margin:0 auto;padding:10px 20px 40px}
|
||||
h1{font-family:var(--titre);font-weight:700;font-size:44px;line-height:1;margin:24px 0 8px;color:var(--sapin)}
|
||||
.accroche{margin:0 0 24px;font-family:var(--titre);font-style:italic;font-size:18px;color:var(--gris)}
|
||||
h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 8px;padding-top:14px;border-top:1px solid var(--pierre);color:var(--sapin)}
|
||||
p,li{font-size:16px}
|
||||
ul{padding-left:20px}
|
||||
li{margin:4px 0}
|
||||
table{border-collapse:collapse;width:100%;font-size:14.5px;margin:10px 0}
|
||||
th,td{border:1px solid var(--roche);padding:7px 10px;text-align:left;vertical-align:top}
|
||||
th{background:#faf9f5;font-weight:600}
|
||||
.pied{max-width:760px;margin:0 auto;padding:16px 20px 40px;border-top:1px solid var(--pierre);font-size:13px;color:var(--gris)}
|
||||
@media (max-width:560px){h1{font-size:34px}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="haut"><a class="retour" href="./">← La carte</a></div>
|
||||
<main>
|
||||
<h1>À propos</h1>
|
||||
<p class="accroche">Des stations de chez nous, des chiffres d'ici.</p>
|
||||
|
||||
<p>Météo Vercors affiche en direct les mesures de stations météo situées dans le Vercors, et uniquement dans le Vercors. C'est un projet personnel et indépendant, sans publicité ni suivi des visiteurs. Il est né d'un constat simple : dans les combes du plateau, il peut faire dix degrés de moins qu'à deux kilomètres de là, et aucune application météo générique ne le montre.</p>
|
||||
|
||||
<h2>Lire la carte</h2>
|
||||
<ul>
|
||||
<li>Chaque étiquette est la température d'une station, colorée du bleu glacier (le froid) au roux (la chaleur). Un « +2 » veut dire que d'autres stations du même village sont regroupées ; en zoomant, elles se séparent.</li>
|
||||
<li>Un toucher (téléphone) ou un clic (ordinateur) ouvre la station. Le plein écran montre les courbes des sept derniers jours : température, humidité, et vent et pluie quand la station a les capteurs (goutte bleue : pluviomètre ; éolienne jaune : anémomètre).</li>
|
||||
<li>Une station muette depuis plus de 30 minutes (40 pour Infoclimat) est marquée « hors ligne » : sa valeur est barrée. Les mesures ne sont jamais moyennées ni fusionnées entre sources.</li>
|
||||
</ul>
|
||||
|
||||
<h2 id="sources">Sources et licences</h2>
|
||||
<table>
|
||||
<tr><th>Source</th><th>Stations</th><th>Mise à jour</th><th>Licence</th></tr>
|
||||
<tr><td>Météo-France, API Observations (paquet 6 minutes)</td><td>Autrans, Villard-de-Lans, La Chapelle-en-Vercors, Col du Rousset, Gresse-en-Vercors, Saint-Jean-en-Royans</td><td>6 minutes</td><td>Licence Ouverte Etalab 2.0</td></tr>
|
||||
<tr><td>Infoclimat (réseau StatIC et stations partenaires)</td><td>Engins, Méaudre, Combe de l'Oscence, Combe de Darbounouse, crête de la Moucherolle, Die, Saint-Julien-en-Quint, Marignac, Cirque d'Archiane, Solaure, Rochechinard, Les Allières, Les Bruyères, Gêve</td><td>10 minutes</td><td>CC BY ou CC BY-NC selon la station (indiquée dans la fiche)</td></tr>
|
||||
<tr><td>WeatherLink (Davis Instruments)</td><td>Les Bruyères, Méaudre, Gêve (stations de Théo Gastinel et de proches)</td><td>15 minutes</td><td>Données des exploitants</td></tr>
|
||||
<tr><td>Station Gastinel (Davis Vantage Pro2)</td><td>Lans-en-Vercors, village</td><td>10 minutes</td><td>Données de l'éditeur</td></tr>
|
||||
</table>
|
||||
<ul>
|
||||
<li>Fond de carte : relief RGE ALTI, cours d'eau, sommets et limite du Parc : © IGN, licence ouverte. Communes : geo.api.gouv.fr. La carte est dessinée une fois pour toutes et servie par ce site : aucun serveur tiers n'est contacté par la page.</li>
|
||||
<li>Polices Bitter et Outfit (licence SIL OFL), hébergées sur ce site.</li>
|
||||
<li>Les stations Infoclimat sous licence CC BY-NC ne servent qu'à un usage non commercial : ce site n'a ni publicité ni offre payante.</li>
|
||||
</ul>
|
||||
<p>Site indépendant, sans lien avec le Parc naturel régional du Vercors ni avec une commune. Les relevés ne remplacent pas un bulletin officiel (Météo-France, Vigilance) pour la sécurité en montagne.</p>
|
||||
|
||||
<h2 id="mentions">Mentions légales</h2>
|
||||
<p><b>Éditeur</b> : Théo Gastinel, micro-entreprise. Directeur de la publication : Théo Gastinel.<br>
|
||||
SIRET et adresse : [À COMPLÉTER].<br>
|
||||
Contact : <a href="mailto:studio@gastinel.me">studio@gastinel.me</a></p>
|
||||
<p><b>Hébergement</b> : [À COMPLÉTER : nom, adresse et contact de l'hébergeur].</p>
|
||||
<p><b>Données personnelles</b> : la page ne dépose aucun cookie et n'a pas de compte. Les journaux techniques du serveur (adresse IP, page demandée) servent à la sécurité ; durée de conservation : voir la politique de confidentialité à venir. Pour toute demande : studio@gastinel.me.</p>
|
||||
<p><b>Propriété</b> : le code et la mise en page sont de Théo Gastinel. Les mesures appartiennent à leurs exploitants (voir sources).</p>
|
||||
</main>
|
||||
<footer class="pied">© Théo Gastinel · <a href="cgu.html">CGU</a> · <a href="confidentialite.html">Confidentialité</a> · <a href="./">Retour à la carte</a></footer>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,73 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<title>À propos · Météo Vercors</title>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
/*POLICES*/
|
||||
:root{--titre:'Bitter',Georgia,serif;--texte:'Outfit',system-ui,sans-serif;--sapin:#1f4d3a;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--gris:#5d635e}
|
||||
*{box-sizing:border-box}
|
||||
html,body{margin:0;background:var(--calcaire);color:var(--roche);font-family:var(--texte);line-height:1.55}
|
||||
a{color:var(--sapin)}
|
||||
a:focus-visible,button:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
.haut{max-width:760px;margin:0 auto;padding:26px 20px 0}
|
||||
.retour{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.12em;text-transform:uppercase;text-decoration:none;color:#fff;background:var(--sapin);padding:8px 12px}
|
||||
main{max-width:760px;margin:0 auto;padding:10px 20px 40px}
|
||||
h1{font-family:var(--titre);font-weight:700;font-size:44px;line-height:1;margin:24px 0 8px;color:var(--sapin)}
|
||||
.accroche{margin:0 0 24px;font-family:var(--titre);font-style:italic;font-size:18px;color:var(--gris)}
|
||||
h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 8px;padding-top:14px;border-top:1px solid var(--pierre);color:var(--sapin)}
|
||||
p,li{font-size:16px}
|
||||
ul{padding-left:20px}
|
||||
li{margin:4px 0}
|
||||
table{border-collapse:collapse;width:100%;font-size:14.5px;margin:10px 0}
|
||||
th,td{border:1px solid var(--roche);padding:7px 10px;text-align:left;vertical-align:top}
|
||||
th{background:#faf9f5;font-weight:600}
|
||||
.pied{max-width:760px;margin:0 auto;padding:16px 20px 40px;border-top:1px solid var(--pierre);font-size:13px;color:var(--gris)}
|
||||
@media (max-width:560px){h1{font-size:34px}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="haut"><a class="retour" href="./">← La carte</a></div>
|
||||
<main>
|
||||
<h1>À propos</h1>
|
||||
<p class="accroche">/*ACCROCHE*/</p>
|
||||
|
||||
<p>Météo Vercors affiche en direct les mesures de stations météo situées dans le Vercors, et uniquement dans le Vercors. C'est un projet personnel et indépendant, sans publicité ni suivi des visiteurs. Il est né d'un constat simple : dans les combes du plateau, il peut faire dix degrés de moins qu'à deux kilomètres de là, et aucune application météo générique ne le montre.</p>
|
||||
|
||||
<h2>Lire la carte</h2>
|
||||
<ul>
|
||||
<li>Chaque étiquette est la température d'une station, colorée du bleu glacier (le froid) au roux (la chaleur). Un « +2 » veut dire que d'autres stations du même village sont regroupées ; en zoomant, elles se séparent.</li>
|
||||
<li>Un toucher (téléphone) ou un clic (ordinateur) ouvre la station. Le plein écran montre les courbes des sept derniers jours : température, humidité, et vent et pluie quand la station a les capteurs (goutte bleue : pluviomètre ; éolienne jaune : anémomètre).</li>
|
||||
<li>Une station muette depuis plus de 30 minutes (40 pour Infoclimat) est marquée « hors ligne » : sa valeur est barrée. Les mesures ne sont jamais moyennées ni fusionnées entre sources.</li>
|
||||
</ul>
|
||||
|
||||
<h2 id="sources">Sources et licences</h2>
|
||||
<table>
|
||||
<tr><th>Source</th><th>Stations</th><th>Mise à jour</th><th>Licence</th></tr>
|
||||
<tr><td>Météo-France, API Observations (paquet 6 minutes)</td><td>Autrans, Villard-de-Lans, La Chapelle-en-Vercors, Col du Rousset, Gresse-en-Vercors, Saint-Jean-en-Royans</td><td>6 minutes</td><td>Licence Ouverte Etalab 2.0</td></tr>
|
||||
<tr><td>Infoclimat (réseau StatIC et stations partenaires)</td><td>Engins, Méaudre, Combe de l'Oscence, Combe de Darbounouse, crête de la Moucherolle, Die, Saint-Julien-en-Quint, Marignac, Cirque d'Archiane, Solaure, Rochechinard, Les Allières, Les Bruyères, Gêve</td><td>10 minutes</td><td>CC BY ou CC BY-NC selon la station (indiquée dans la fiche)</td></tr>
|
||||
<tr><td>WeatherLink (Davis Instruments)</td><td>Les Bruyères, Méaudre, Gêve (stations de Théo Gastinel et de proches)</td><td>15 minutes</td><td>Données des exploitants</td></tr>
|
||||
<tr><td>Station Gastinel (Davis Vantage Pro2)</td><td>Lans-en-Vercors, village</td><td>10 minutes</td><td>Données de l'éditeur</td></tr>
|
||||
</table>
|
||||
<ul>
|
||||
<li>Fond de carte : relief RGE ALTI, cours d'eau, sommets et limite du Parc : © IGN, licence ouverte. Communes : geo.api.gouv.fr. La carte est dessinée une fois pour toutes et servie par ce site : aucun serveur tiers n'est contacté par la page.</li>
|
||||
<li>Polices Bitter et Outfit (licence SIL OFL), hébergées sur ce site.</li>
|
||||
<li>Les stations Infoclimat sous licence CC BY-NC ne servent qu'à un usage non commercial : ce site n'a ni publicité ni offre payante.</li>
|
||||
</ul>
|
||||
<p>Site indépendant, sans lien avec le Parc naturel régional du Vercors ni avec une commune. Les relevés ne remplacent pas un bulletin officiel (Météo-France, Vigilance) pour la sécurité en montagne.</p>
|
||||
|
||||
<h2 id="mentions">Mentions légales</h2>
|
||||
<p><b>Éditeur</b> : Théo Gastinel, micro-entreprise. Directeur de la publication : Théo Gastinel.<br>
|
||||
SIRET et adresse : [À COMPLÉTER].<br>
|
||||
Contact : <a href="mailto:studio@gastinel.me">studio@gastinel.me</a></p>
|
||||
<p><b>Hébergement</b> : [À COMPLÉTER : nom, adresse et contact de l'hébergeur].</p>
|
||||
<p><b>Données personnelles</b> : la page ne dépose aucun cookie et n'a pas de compte. Les journaux techniques du serveur (adresse IP, page demandée) servent à la sécurité ; durée de conservation : voir la politique de confidentialité à venir. Pour toute demande : studio@gastinel.me.</p>
|
||||
<p><b>Propriété</b> : le code et la mise en page sont de Théo Gastinel. Les mesures appartiennent à leurs exploitants (voir sources).</p>
|
||||
</main>
|
||||
<footer class="pied">© Théo Gastinel · <a href="./">Retour à la carte</a></footer>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,42 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Assemble le site publiable de vercors.me dans <projet>/site-v2/ à partir de la maquette.
|
||||
|
||||
site-v2/index.html, a-propos.html, (cgu.html, confidentialite.html si présents), polices/, tuiles/, data/ (vide)
|
||||
Les JSON de données (data/*.json, data/semaine/) sont produits sur cornafserver et copiés sur le serveur public à part.
|
||||
Usage : python assembler.py
|
||||
"""
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
ICI = os.path.dirname(os.path.abspath(__file__))
|
||||
DEST = os.path.join(os.path.dirname(os.path.dirname(ICI)), "site-v2")
|
||||
PAGES = ("index.html", "a-propos.html", "cgu.html", "confidentialite.html")
|
||||
|
||||
|
||||
def main():
|
||||
shutil.rmtree(DEST, ignore_errors=True)
|
||||
os.makedirs(os.path.join(DEST, "data"))
|
||||
for nom in PAGES:
|
||||
src = os.path.join(ICI, "a-propos-build.html" if nom == "a-propos.html" else nom)
|
||||
if os.path.exists(src):
|
||||
shutil.copy(src, os.path.join(DEST, nom))
|
||||
for dossier in ("polices", "tuiles"):
|
||||
src = os.path.join(ICI, dossier)
|
||||
if os.path.isdir(src):
|
||||
shutil.copytree(src, os.path.join(DEST, dossier), ignore=shutil.ignore_patterns("*.css"))
|
||||
# contrôle : aucune ressource distante dans les pages
|
||||
for nom in os.listdir(DEST):
|
||||
if nom.endswith(".html"):
|
||||
texte = open(os.path.join(DEST, nom), encoding="utf-8").read()
|
||||
for motif in ("https://fonts.", "//cdn.", "<script src=\"http", "<link href=\"http"):
|
||||
if motif in texte:
|
||||
print("ATTENTION : ressource distante dans", nom, motif)
|
||||
return 1
|
||||
taille = sum(os.path.getsize(os.path.join(d, f)) for d, _, fs in os.walk(DEST) for f in fs)
|
||||
print("site-v2 assemblé : %d fichiers, %.1f Mo -> %s" % (sum(len(f) for _, _, f in os.walk(DEST)), taille / 1e6, DEST))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,111 @@
|
||||
# Assemble la maquette d'accueil : index.html autonome (SVG en ligne + script).
|
||||
import json
|
||||
|
||||
c = json.load(open('carte.json', encoding='utf-8'))
|
||||
L = c['lieux']
|
||||
|
||||
def lieu(nom, prio, typ=None, alias=None, ele=None, pos=None):
|
||||
p = L.get(nom, {})
|
||||
lon, lat = pos or (p['lon'], p['lat'])
|
||||
t = typ or ('pic' if p.get('type') == 'peak' else p.get('type', 'village'))
|
||||
return {'n': alias or nom, 'lon': lon, 'lat': lat, 'p': prio, 't': t, 'ele': ele}
|
||||
|
||||
etiquettes = [
|
||||
# villages (mairies, geo.api.gouv.fr)
|
||||
lieu('Villard-de-Lans', 1), lieu('La Chapelle-en-Vercors', 1), lieu('Die', 1, 'village'),
|
||||
lieu('Pont-en-Royans', 1), lieu('Saint-Jean-en-Royans', 1), lieu('Gresse-en-Vercors', 1),
|
||||
lieu('Vassieux-en-Vercors', 1), lieu('Corrençon-en-Vercors', 2),
|
||||
lieu('Autrans', 1, 'village', pos=(5.5442, 45.176)), lieu('Méaudre', 2, 'village', pos=(5.5271, 45.1269)),
|
||||
lieu('Lans-en-Vercors', 2), lieu('Engins', 2), lieu('Saint-Nizier-du-Moucherotte', 3),
|
||||
lieu('Saint-Julien-en-Vercors', 2), lieu('Saint-Martin-en-Vercors', 2), lieu('Saint-Agnan-en-Vercors', 2),
|
||||
lieu('Rencurel', 2), lieu('Chichilianne', 2), lieu('Châtillon-en-Diois', 2), lieu('Bouvante', 2),
|
||||
lieu('Monestier-de-Clermont', 2), lieu('Romeyer', 3), lieu('Malleval-en-Vercors', 3),
|
||||
lieu('Choranche', 3), lieu('Léoncel', 3), lieu('Glandage', 3),
|
||||
# villes autour
|
||||
lieu('Grenoble', 1, 'ville'), lieu('Saint-Marcellin', 2, 'ville'), lieu('Vif', 2, 'ville'),
|
||||
# sommets (BD TOPO ; altitudes de la carte IGN)
|
||||
lieu('le Grand Veymont', 1, alias='Grand Veymont', ele=2341),
|
||||
lieu('Mont Aiguille', 1, ele=2087),
|
||||
lieu('la Grande Moucherolle', 2, alias='Grande Moucherolle', ele=2284),
|
||||
lieu('le Moucherotte', 2, alias='Moucherotte', ele=1901),
|
||||
lieu('Pic Saint-Michel', 3, ele=1966), lieu('Roc Cornafion', 3, ele=2049),
|
||||
lieu('But Saint-Genix', 3, ele=1645),
|
||||
# régions (placées à la main)
|
||||
{'n': 'Royans', 'lon': 5.235, 'lat': 45.085, 'p': 1, 't': 'region'},
|
||||
{'n': 'Diois', 'lon': 5.45, 'lat': 44.72, 'p': 1, 't': 'region'},
|
||||
{'n': 'Trièves', 'lon': 5.675, 'lat': 44.855, 'p': 1, 't': 'region'},
|
||||
{'n': 'Hauts-Plateaux', 'lon': 5.47, 'lat': 44.885, 'p': 2, 't': 'region'},
|
||||
{'n': 'Quatre-Montagnes', 'lon': 5.45, 'lat': 45.19, 'p': 2, 't': 'region'},
|
||||
{'n': "Vallée de l'Isère", 'lon': 5.42, 'lat': 45.245, 'p': 2, 't': 'region'},
|
||||
{'n': 'Chartreuse', 'lon': 5.775, 'lat': 45.285, 'p': 2, 't': 'region'},
|
||||
{'n': 'Gorges de la Bourne', 'lon': 5.425, 'lat': 45.083, 'p': 3, 't': 'lieudit'},
|
||||
{'n': 'Forêt de Lente', 'lon': 5.315, 'lat': 44.955, 'p': 3, 't': 'lieudit'},
|
||||
]
|
||||
|
||||
carte = {k: c[k] for k in ('vw', 'vh', 'k', 'm', 'lon0', 'lat1')}
|
||||
|
||||
# fond large (flouté autour du Parc) + détail dans le Parc + limite du Parc + fleuves nets
|
||||
lg = json.load(open('large.json', encoding='utf-8'))
|
||||
pn = json.load(open('pnr.json', encoding='utf-8'))
|
||||
X0, Y0, LW, LH = lg['cadre']
|
||||
zone = f'x="{X0}" y="{Y0}" width="{LW}" height="{LH}"'
|
||||
teintes = ''.join(f'<path class="h{t}" d="{d}"/>' for t, d in c['teintes'])
|
||||
# couleurs posées en attribut : le CSS n'atteint pas le contenu réutilisé par <use>
|
||||
FOND = {0: '#f2f0e8', 500: '#ebede1', 900: '#e2e8d6', 1300: '#d5dfc7', 1700: '#e3dfd2', 2000: '#ece9e0', 2200: '#f3f1eb'}
|
||||
teintes_l = ''.join(f'<path fill="{FOND[t]}" d="{d}"/>' for t, d in lg['teintes'])
|
||||
V = 'style="vector-effect:non-scaling-stroke"'
|
||||
# chaque grand calque n'est écrit qu'une fois (defs) et réutilisé par <use>
|
||||
# deux couches : derrière, les alentours (flou CSS, fait par la carte graphique) ;
|
||||
# devant, le Parc détaillé (masqué par sa limite), la limite et les fleuves.
|
||||
fond = (f'<svg id="fond" class="couche" viewBox="0 0 {c["vw"]} {c["vh"]}" preserveAspectRatio="none" aria-hidden="true">'
|
||||
f'<g id="d-large"><rect fill="{FOND[0]}" {zone}/>{teintes_l}</g>'
|
||||
f'<path class="courbe" d="{lg["courbes"]}"/><rect class="voile" {zone}/></svg>')
|
||||
svg = fond + (f'<svg id="relief" class="couche" viewBox="0 0 {c["vw"]} {c["vh"]}" preserveAspectRatio="none" aria-hidden="true">'
|
||||
f'<defs><path id="d-pnr" {V} d="{pn["pnr"]}"/>'
|
||||
f'<mask id="m-dedans" maskUnits="userSpaceOnUse" {zone}><use href="#d-pnr" fill="#fff"/></mask>'
|
||||
f'<path id="d-moy" {V} d="{lg["moyennes"]}"/><path id="d-gr" {V} d="{lg["rivieres"]}"/></defs>'
|
||||
f'<g mask="url(#m-dedans)"><use href="#d-large"/>{teintes}'
|
||||
f'<path class="courbe" d="{c["courbes"]}"/>'
|
||||
f'<path class="courbe maitresse" d="{c["maitresses"]}"/>'
|
||||
f'<path class="riviere" d="{c["riv_p"]}"/></g>'
|
||||
f'<use class="limite-halo" href="#d-pnr"/><use class="limite" href="#d-pnr"/>'
|
||||
f'<use class="fleuve-halo moyen" href="#d-moy"/><use class="riviere moyenne" href="#d-moy"/>'
|
||||
f'<use class="fleuve-halo" href="#d-gr"/><use class="riviere grande" href="#d-gr"/>'
|
||||
'</svg>')
|
||||
|
||||
# fleuves et villes des alentours (mairies geo.api.gouv.fr)
|
||||
etiquettes += pn['fleuves']
|
||||
# le Rhône, posé sur son cours près de Valence
|
||||
rh = min(((lo, la) for ft in json.load(open('ce-large.json', encoding='utf-8'))['features'] if ft['properties']['toponyme'] == 'le Rhône'
|
||||
for l in ft['geometry']['coordinates'] for lo, la, *_ in l), key=lambda p: abs(p[0] - 4.87) * 0.7 + abs(p[1] - 45.0))
|
||||
etiquettes.append({'n': 'Rhône', 'lon': rh[0], 'lat': rh[1], 'p': 1, 't': 'fleuve'})
|
||||
mairies = {x['nom']: x['mairie']['coordinates'] for d in ('26', '38') for x in json.load(open(f'com{d}.json', encoding='utf-8'))}
|
||||
for nom, p in (('Valence', 1), ('Romans-sur-Isère', 1), ('Voiron', 1), ('Crest', 2), ('La Mure', 2), ('Mens', 2), ('Saint-Égrève', 3)):
|
||||
lo, la = mairies[nom]
|
||||
etiquettes.append({'n': nom, 'lon': lo, 'lat': la, 'p': p, 't': 'ville'})
|
||||
|
||||
# page de rendu : la carte seule, pour découper les images (tuiles.py)
|
||||
import os
|
||||
styles = '\n'.join(l for l in open('modele.html', encoding='utf-8').read().split('\n') if l.startswith('.couche .'))
|
||||
open('rendu.html', 'w', encoding='utf-8').write(
|
||||
'<!doctype html><html><head><meta charset="utf-8"><style>:root{--sapin:#1f4d3a;--glacier:#6eb5bd}'
|
||||
'html,body{margin:0;overflow:hidden;background:#f2f0e8}.couche{position:absolute;left:0;top:0;width:100%;height:100%}'
|
||||
'#fond{filter:blur(2px)}\n' + styles + '\n'
|
||||
# zooms forts : courbes plus marquées
|
||||
'body[data-n="2"] .couche .courbe{stroke-opacity:.24;stroke-width:.7px}body[data-n="2"] .couche .maitresse{stroke-opacity:.42;stroke-width:1.1px}'
|
||||
'body[data-n="3"] .couche .courbe{stroke-opacity:.3;stroke-width:.9px}body[data-n="3"] .couche .maitresse{stroke-opacity:.5;stroke-width:1.4px}' + '</style></head><body>' + svg +
|
||||
'<script>window.poser=(x,y,s)=>{const v=`${x} ${y} ${innerWidth/s} ${innerHeight/s}`;'
|
||||
'document.querySelectorAll(".couche").forEach(e=>e.setAttribute("viewBox",v));}</script></body></html>')
|
||||
|
||||
# page publiée : les images pré-calculées remplacent le SVG ; un tracé caché du Parc sert à savoir si la souris est dedans
|
||||
tuiles = json.load(open('tuiles/manifeste.json', encoding='utf-8')) if os.path.exists('tuiles/manifeste.json') else {}
|
||||
carte_html = ('<div id="tuiles" aria-hidden="true"></div>'
|
||||
f'<svg width="0" height="0" style="position:absolute" aria-hidden="true"><path id="d-pnr" d="{pn["pnr"]}"/></svg>')
|
||||
page = open('modele.html', encoding='utf-8').read()
|
||||
page = (page.replace('/*CARTE*/', json.dumps(carte))
|
||||
.replace('/*TUILES*/', json.dumps(tuiles))
|
||||
.replace('/*INTRO*/', open('intro.json').read() if os.path.exists('intro.json') else '[]')
|
||||
.replace('/*ETIQUETTES*/', json.dumps(etiquettes, ensure_ascii=False))
|
||||
.replace('<!--SVG-->', carte_html))
|
||||
open('index.html', 'w', encoding='utf-8').write(page)
|
||||
print('index.html', len(page.encode('utf-8')) // 1024, 'Ko')
|
||||
@@ -0,0 +1,119 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Conditions générales d'utilisation de Météo Vercors.">
|
||||
<title>Conditions d'utilisation · Météo Vercors</title>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(polices/bitter-italic.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Bitter';font-style:normal;font-weight:500 700;font-display:swap;src:url(polices/bitter-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Outfit';font-style:normal;font-weight:400 600;font-display:swap;src:url(polices/outfit-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
:root{--titre:'Bitter',Georgia,serif;--texte:'Outfit',system-ui,sans-serif;--sapin:#1f4d3a;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--gris:#5d635e}
|
||||
*{box-sizing:border-box}
|
||||
html,body{margin:0;background:var(--calcaire);color:var(--roche);font-family:var(--texte);line-height:1.55}
|
||||
a{color:var(--sapin)}
|
||||
a:focus-visible,button:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
.haut{max-width:760px;margin:0 auto;padding:26px 20px 0}
|
||||
.retour{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.12em;text-transform:uppercase;text-decoration:none;color:#fff;background:var(--sapin);padding:8px 12px}
|
||||
main{max-width:760px;margin:0 auto;padding:10px 20px 40px}
|
||||
h1{font-family:var(--titre);font-weight:700;font-size:44px;line-height:1;margin:24px 0 8px;color:var(--sapin)}
|
||||
.accroche{margin:0 0 24px;font-family:var(--titre);font-style:italic;font-size:18px;color:var(--gris)}
|
||||
h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 8px;padding-top:14px;border-top:1px solid var(--pierre);color:var(--sapin)}
|
||||
p,li{font-size:16px}
|
||||
ul{padding-left:20px}
|
||||
li{margin:4px 0}
|
||||
table{border-collapse:collapse;width:100%;font-size:14.5px;margin:10px 0}
|
||||
th,td{border:1px solid var(--roche);padding:7px 10px;text-align:left;vertical-align:top}
|
||||
th{background:#faf9f5;font-weight:600}
|
||||
.pied{max-width:760px;margin:0 auto;padding:16px 20px 40px;border-top:1px solid var(--pierre);font-size:13px;color:var(--gris)}
|
||||
@media (max-width:560px){h1{font-size:34px}}
|
||||
.avert{border-left:3px solid var(--sapin);background:#faf9f5;padding:10px 14px;font-size:15px}
|
||||
.a-trancher{background:#fff4d6}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="haut"><a class="retour" href="./">← La carte</a></div>
|
||||
<main>
|
||||
<h1>Conditions générales d'utilisation de vercors.me (Météo Vercors)</h1>
|
||||
<p class="accroche">Les règles du site, les sources et leurs licences.</p>
|
||||
<p class="avert"><b>Projet de texte, à faire relire par un juriste avant publication.</b> Rédigé par Claude (qui n'est pas avocat) le 04/11/2026 sur le modèle des CGV et de la politique de confidentialité de gastinel.me. Les mentions <mark class="a-trancher">[À COMPLÉTER]</mark> et <mark class="a-trancher">[À VÉRIFIER]</mark> doivent être levées avant la mise en ligne.</p>
|
||||
<p>Version 0.1 (projet) — Date d'entrée en vigueur : <mark class="a-trancher">[À COMPLÉTER]</mark></p>
|
||||
<h2>Préambule</h2>
|
||||
<p>Les présentes conditions générales d'utilisation (CGU) encadrent l'accès au site <b>vercors.me</b> (« Météo Vercors », ci-après « le Site ») et son utilisation par toute personne qui le consulte (ci-après « l'Utilisateur »). Consulter le Site vaut acceptation des présentes CGU, accessibles à tout moment depuis chaque page.</p>
|
||||
<p>La politique de confidentialité, document distinct et autonome, décrit le traitement des données personnelles.</p>
|
||||
<h2>Article 1 : Éditeur et hébergement</h2>
|
||||
<ul>
|
||||
<li><b>Éditeur</b> : Théo Gastinel, micro-entreprise. SIRET : <mark class="a-trancher">[À COMPLÉTER]</mark>. Adresse : <mark class="a-trancher">[À COMPLÉTER]</mark>. <mark class="a-trancher">[À VÉRIFIER : gastinel.me désigne comme éditeur « Richard GASTINEL, entrepreneur individuel (EI) » ; l'éditeur de vercors.me doit être la personne qui détient le SIRET indiqué.]</mark></li>
|
||||
<li><b>Directeur de la publication</b> : Théo Gastinel.</li>
|
||||
<li><b>Contact</b> : <a href="mailto:studio@gastinel.me">studio@gastinel.me</a></li>
|
||||
<li><b>Hébergeur</b> : <mark class="a-trancher">[À COMPLÉTER : nom ou raison sociale, adresse et téléphone, mentions obligatoires au titre de l'article 6-III de la loi n° 2004-575 du 21 juin 2004 pour la confiance dans l'économie numérique (LCEN)]</mark>.</li>
|
||||
</ul>
|
||||
<h2>Article 2 : Objet du Site</h2>
|
||||
<p>Le Site affiche en direct les mesures de stations météorologiques situées dans le Vercors : carte des stations, courbes des sept derniers jours (température, humidité, et vent et pluie selon les capteurs) et archive des relevés. C'est un projet personnel, indépendant et non commercial, sans lien avec le Parc naturel régional du Vercors ni avec une commune.</p>
|
||||
<p>Le Site ne contient <b>aucune publicité</b>, ni aujourd'hui ni à l'avenir, et ne propose aucune offre payante.</p>
|
||||
<h2>Article 3 : Accès au Site</h2>
|
||||
<p>3.1. Le Site est accessible gratuitement, sans inscription ni compte. Les frais de connexion à Internet restent à la charge de l'Utilisateur.</p>
|
||||
<p>3.2. L'éditeur s'efforce de maintenir le Site accessible, sans obligation de résultat. L'accès peut être interrompu, notamment pour maintenance, panne du serveur, coupure électrique ou réseau, ou indisponibilité d'une source de données. Ces interruptions n'ouvrent droit à aucune indemnité.</p>
|
||||
<p>3.3. L'éditeur peut limiter ou bloquer l'accès d'un Utilisateur dont l'usage compromet le fonctionnement du Site (requêtes automatisées massives, tentative d'intrusion, etc.).</p>
|
||||
<p>3.4. La consultation par des robots est tolérée tant qu'elle reste raisonnable et ne dégrade pas le service. La récupération systématique des données relève de l'article 6. <mark class="a-trancher">[À VÉRIFIER : cohérence avec le robots.txt de vercors.me.]</mark></p>
|
||||
<h2>Article 4 : Nature des informations et absence de garantie</h2>
|
||||
<p>4.1. Les relevés affichés sont des <b>mesures brutes</b> issues de stations exploitées par des tiers ou par l'éditeur. Ils ne sont ni moyennés ni fusionnés entre sources, et ne sont pas contrôlés par l'éditeur avant affichage.</p>
|
||||
<p>4.2. L'éditeur ne garantit ni l'<b>exactitude</b>, ni l'<b>exhaustivité</b>, ni l'<b>actualité</b> des mesures, ni la <b>disponibilité</b> des stations. Une station peut être mal placée, mal étalonnée, en panne ou hors ligne. Une station muette depuis plus de 30 minutes (40 minutes pour Infoclimat) est signalée « hors ligne », sa dernière valeur étant barrée.</p>
|
||||
<p>4.3. Le Site ne délivre <b>aucune prévision</b>, <b>aucun avis de santé</b> et <b>aucun conseil de sécurité</b>.</p>
|
||||
<h2>Article 5 : Sécurité en montagne</h2>
|
||||
<p><b>Les relevés de ce Site ne remplacent en aucun cas un bulletin officiel.</b> Avant toute activité en montagne (randonnée, ski, alpinisme, spéléologie, vol libre, etc.), l'Utilisateur consulte les sources officielles : prévisions et vigilance de Météo-France, bulletin d'estimation du risque d'avalanche (BERA), consignes des autorités locales.</p>
|
||||
<p>Une mesure, même récente, ne dit rien de l'évolution à venir ni des conditions à quelques centaines de mètres de la station. L'Utilisateur reste seul responsable de ses décisions et de sa sécurité. L'éditeur ne pourra être tenu responsable d'un dommage résultant d'une décision prise sur la seule base des informations du Site.</p>
|
||||
<h2>Article 6 : Sources, licences et réutilisation des données</h2>
|
||||
<p>6.1. <b>Sources</b> :</p>
|
||||
<table>
|
||||
<tr><th>Source</th><th>Licence</th><th>Obligation</th></tr>
|
||||
<tr><td>Météo-France (API Observations)</td><td>Licence Ouverte Etalab 2.0</td><td>Citer « Météo-France » et la date de dernière mise à jour</td></tr>
|
||||
<tr><td>Infoclimat (réseau StatIC et stations partenaires)</td><td>CC BY ou CC BY-NC selon la station (indiquée dans sa fiche)</td><td>Citer Infoclimat et la station ; CC BY-NC : aucun usage commercial</td></tr>
|
||||
<tr><td>WeatherLink (Davis Instruments)</td><td>Données des exploitants</td><td>Accord de chaque exploitant <mark class="a-trancher">[À VÉRIFIER : accord écrit]</mark></td></tr>
|
||||
<tr><td>Station Gastinel (Davis Vantage Pro2)</td><td>Données de l'éditeur</td><td>—</td></tr>
|
||||
<tr><td>Fond de carte (relief RGE ALTI, cours d'eau, sommets, limite du Parc)</td><td>© IGN, licence ouverte <mark class="a-trancher">[À VÉRIFIER : Licence Ouverte Etalab 2.0]</mark></td><td>Citer « © IGN »</td></tr>
|
||||
<tr><td>Communes (geo.api.gouv.fr)</td><td><mark class="a-trancher">[À VÉRIFIER]</mark></td><td>—</td></tr>
|
||||
<tr><td>Polices Bitter et Outfit</td><td>SIL Open Font License</td><td>—</td></tr>
|
||||
</table>
|
||||
<p>6.2. Les stations Infoclimat sous licence CC BY-NC ne sont affichées qu'en raison du caractère non commercial du Site (aucune publicité, aucune offre payante). Si cette condition cessait, ces stations seraient retirées.</p>
|
||||
<p>6.3. <b>Reprise des données par un tiers</b> : les mesures appartiennent à leurs exploitants. Quiconque souhaite réutiliser des données affichées sur le Site doit respecter la licence de la source d'origine (tableau ci-dessus) ; l'éditeur ne concède aucun droit sur des données qui ne lui appartiennent pas. Les données des stations WeatherLink privées et de la station Gastinel ne peuvent être reprises qu'avec l'accord écrit de leur exploitant (demande à <a href="mailto:studio@gastinel.me">studio@gastinel.me</a>). L'extraction systématique de l'archive par des moyens automatisés est soumise à l'accord préalable de l'éditeur. <mark class="a-trancher">[À VÉRIFIER : droit du producteur de base de données (art. L. 341-1 du Code de la propriété intellectuelle) sur l'archive.]</mark></p>
|
||||
<p>6.4. <b>Archive</b> : les relevés sont conservés sans limite de durée. Ce sont des données météorologiques, non des données personnelles.</p>
|
||||
<h2>Article 7 : Propriété intellectuelle</h2>
|
||||
<p>7.1. Le code, la mise en page, les textes, la charte graphique et la carte telle que dessinée pour le Site sont la propriété de Théo Gastinel, sous réserve des éléments de tiers cités à l'article 6. Toute reproduction ou représentation, totale ou partielle, sans autorisation écrite est interdite (art. L. 122-4 du Code de la propriété intellectuelle). <mark class="a-trancher">[À COMPLÉTER : si le code est un jour publié sous licence libre, le préciser ici.]</mark></p>
|
||||
<p>7.2. Les mesures appartiennent à leurs exploitants respectifs.</p>
|
||||
<p>7.3. Les noms et marques cités (Météo-France, Infoclimat, Davis, WeatherLink, IGN) appartiennent à leurs titulaires ; leur mention vaut seulement citation de source.</p>
|
||||
<h2>Article 8 : Liens</h2>
|
||||
<p>8.1. Le Site contient des liens vers des sites tiers (sources, organismes officiels). L'éditeur n'exerce aucun contrôle sur eux et décline toute responsabilité quant à leur contenu.</p>
|
||||
<p>8.2. Tout site peut créer un lien simple vers vercors.me sans autorisation préalable, à condition de ne pas l'afficher dans un cadre (iframe) qui le présenterait comme sien et de ne pas en dénaturer le contenu.</p>
|
||||
<h2>Article 9 : Limitation de responsabilité</h2>
|
||||
<p>Dans les limites permises par la loi, l'éditeur ne saurait être tenu responsable des erreurs, retards ou absences de mesures, des interruptions du Site, des dommages résultant de l'usage des informations affichées, ni du contenu des sites tiers. Rien dans les présentes n'exclut la responsabilité de l'éditeur pour faute lourde ou intentionnelle, ni les droits que l'Utilisateur tient de la loi. <mark class="a-trancher">[À VÉRIFIER par un juriste : portée de cette clause pour un service gratuit.]</mark></p>
|
||||
<h2>Article 10 : Comptes, forum et contenus des utilisateurs</h2>
|
||||
<p><b>Service non ouvert à ce jour — cet article s'appliquera à compter de l'ouverture des comptes et du forum.</b></p>
|
||||
<p>10.1. <b>Comptes</b> : les comptes passeront par <b>Gastinel Hub</b>, le compte commun aux services Gastinel, dont les conditions s'appliqueront en complément. Âge minimal : 15 ans <mark class="a-trancher">[À VÉRIFIER : règle des services gratuits Gastinel, à confirmer pour le forum]</mark>.</p>
|
||||
<p>10.2. <b>Rôles</b> :</p>
|
||||
<ul>
|
||||
<li><i>Visiteur</i> : lit le Site et le forum, sans compte.</li>
|
||||
<li><i>Membre</i> : titulaire d'un compte ; peut <mark class="a-trancher">[À COMPLÉTER : répondre, signaler…]</mark>.</li>
|
||||
<li><i>Adhérent météo</i> : membre autorisé à publier sur le forum (relevés, observations, photos).</li>
|
||||
<li><i>Modérateur</i> : désigné par l'éditeur ; traite les signalements et peut masquer un contenu.</li>
|
||||
<li><i>Administrateur</i> : l'éditeur.</li>
|
||||
</ul>
|
||||
<p>10.3. <b>Règles de publication</b> : l'Utilisateur ne publie que des contenus licites, en rapport avec la météo et le Vercors. Sont notamment interdits : les contenus injurieux, diffamatoires, haineux, discriminatoires ou violents ; l'atteinte à la vie privée ou au droit à l'image (photographie d'une personne reconnaissable sans son accord) ; la contrefaçon (photo ou texte d'autrui sans droit) ; la publicité et le démarchage ; la diffusion de données personnelles de tiers ; les fausses alertes de nature à mettre en danger.</p>
|
||||
<p>10.4. <b>Responsabilité</b> : chaque auteur est seul responsable de ses contributions. Pour leur stockage, l'éditeur agit en qualité d'<b>hébergeur</b> au sens de l'article 6-I-2 de la LCEN : il n'exerce aucune surveillance générale a priori et retire promptement tout contenu manifestement illicite dès qu'il en a connaissance. <mark class="a-trancher">[À VÉRIFIER : obligations du règlement européen sur les services numériques (DSA, règlement (UE) 2022/2065), notamment ses articles 16 (notification) et 17 (motivation des décisions).]</mark></p>
|
||||
<p>10.5. <b>Signalement</b> : chaque contribution comporte un bouton de signalement gratuit et facile d'accès, doublé de l'adresse <a href="mailto:studio@gastinel.me">studio@gastinel.me</a>. Le signalement précise le contenu visé et les motifs. Un signalement abusif fait dans l'intention de nuire peut être sanctionné.</p>
|
||||
<p>10.6. <b>Modération et retrait</b> : les modérateurs peuvent masquer ou retirer un contenu, ou suspendre un compte, en cas de manquement aux présentes. L'auteur est informé de la décision et de ses motifs, et peut la contester à <a href="mailto:studio@gastinel.me">studio@gastinel.me</a>. En cas de manquement grave ou répété, le compte peut être fermé.</p>
|
||||
<p>10.7. <b>Propriété des contributions</b> : l'auteur reste propriétaire de ses contributions. En publiant, il concède à l'éditeur, à titre gratuit et non exclusif, le droit de les reproduire et de les afficher sur le Site, pour la durée de leur mise en ligne et aux seules fins du forum. Aucune contribution n'est utilisée à une autre fin : ni publicité, ni revente, ni entraînement d'intelligence artificielle. <mark class="a-trancher">[À COMPLÉTER : si les relevés publiés par un adhérent rejoignent l'archive météo sans limite de durée, le prévoir ici explicitement.]</mark></p>
|
||||
<p>10.8. <b>Suppression</b> : l'auteur peut supprimer ses contributions et son compte à tout moment. Ses données personnelles sont alors effacées selon la politique de confidentialité, sous réserve des données d'identification des auteurs que la loi impose de conserver.</p>
|
||||
<h2>Article 11 : Données personnelles et cookies</h2>
|
||||
<p>Le traitement des données personnelles est décrit dans la <b>politique de confidentialité</b> de vercors.me. Le Site ne dépose aucun cookie tiers et ne contacte aucun serveur tiers : la carte et les polices sont servies par le Site lui-même.</p>
|
||||
<h2>Article 12 : Modification des CGU</h2>
|
||||
<p>L'éditeur peut modifier les présentes CGU. La version applicable est celle en ligne au moment de la consultation ; sa date figure en tête. Une fois les comptes ouverts, toute modification substantielle sera signalée aux membres avant son entrée en vigueur.</p>
|
||||
<h2>Article 13 : Droit applicable et litiges</h2>
|
||||
<p>Les présentes CGU sont soumises au droit français. En cas de litige, l'Utilisateur contacte d'abord l'éditeur à <a href="mailto:studio@gastinel.me">studio@gastinel.me</a> pour rechercher une solution amiable. À défaut, les tribunaux français sont compétents, sous réserve des règles protectrices du consommateur. <mark class="a-trancher">[À VÉRIFIER : applicabilité de la médiation de la consommation à un service gratuit.]</mark></p>
|
||||
</main>
|
||||
<footer class="pied">© Théo Gastinel · <a href="cgu.html">Conditions d'utilisation</a> · <a href="confidentialite.html">Confidentialité</a> · <a href="./">Retour à la carte</a></footer>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,123 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Politique de confidentialité de Météo Vercors : données, durées, droits.">
|
||||
<title>Confidentialité · Météo Vercors</title>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(polices/bitter-italic.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Bitter';font-style:normal;font-weight:500 700;font-display:swap;src:url(polices/bitter-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Outfit';font-style:normal;font-weight:400 600;font-display:swap;src:url(polices/outfit-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
:root{--titre:'Bitter',Georgia,serif;--texte:'Outfit',system-ui,sans-serif;--sapin:#1f4d3a;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--gris:#5d635e}
|
||||
*{box-sizing:border-box}
|
||||
html,body{margin:0;background:var(--calcaire);color:var(--roche);font-family:var(--texte);line-height:1.55}
|
||||
a{color:var(--sapin)}
|
||||
a:focus-visible,button:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
.haut{max-width:760px;margin:0 auto;padding:26px 20px 0}
|
||||
.retour{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.12em;text-transform:uppercase;text-decoration:none;color:#fff;background:var(--sapin);padding:8px 12px}
|
||||
main{max-width:760px;margin:0 auto;padding:10px 20px 40px}
|
||||
h1{font-family:var(--titre);font-weight:700;font-size:44px;line-height:1;margin:24px 0 8px;color:var(--sapin)}
|
||||
.accroche{margin:0 0 24px;font-family:var(--titre);font-style:italic;font-size:18px;color:var(--gris)}
|
||||
h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 8px;padding-top:14px;border-top:1px solid var(--pierre);color:var(--sapin)}
|
||||
p,li{font-size:16px}
|
||||
ul{padding-left:20px}
|
||||
li{margin:4px 0}
|
||||
table{border-collapse:collapse;width:100%;font-size:14.5px;margin:10px 0}
|
||||
th,td{border:1px solid var(--roche);padding:7px 10px;text-align:left;vertical-align:top}
|
||||
th{background:#faf9f5;font-weight:600}
|
||||
.pied{max-width:760px;margin:0 auto;padding:16px 20px 40px;border-top:1px solid var(--pierre);font-size:13px;color:var(--gris)}
|
||||
@media (max-width:560px){h1{font-size:34px}}
|
||||
.avert{border-left:3px solid var(--sapin);background:#faf9f5;padding:10px 14px;font-size:15px}
|
||||
.a-trancher{background:#fff4d6}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="haut"><a class="retour" href="./">← La carte</a></div>
|
||||
<main>
|
||||
<h1>Politique de confidentialité de vercors.me (Météo Vercors)</h1>
|
||||
<p class="accroche">Peu de données, aucune publicité, aucun traceur tiers.</p>
|
||||
<p class="avert"><b>Projet de texte, à faire relire par un juriste avant publication.</b> Rédigé par Claude (qui n'est pas avocat) le 04/11/2026 sur le modèle de la politique de confidentialité de gastinel.me (version 5.6). La section 4 (personnalisation par adresse IP) décrit un projet dont la conformité reste à trancher : voir <code>Points-a-trancher.md</code>. Les mentions <mark class="a-trancher">[À COMPLÉTER]</mark> et <mark class="a-trancher">[À VÉRIFIER]</mark> doivent être levées avant la mise en ligne.</p>
|
||||
<p>Version 0.1 (projet) — Date d'entrée en vigueur : <mark class="a-trancher">[À COMPLÉTER]</mark></p>
|
||||
<p>Cette page décrit de manière autonome la façon dont vos données personnelles sont collectées, utilisées et protégées sur vercors.me, et les droits dont vous disposez. Elle constitue l'information prévue aux articles 12 et 13 du Règlement général sur la protection des données (RGPD). Elle se lit sans avoir à consulter les conditions générales d'utilisation.</p>
|
||||
<p><b>En bref</b> : pas de publicité, pas de cookie tiers, pas d'outil d'analyse, pas de compte aujourd'hui. La page ne contacte aucun serveur tiers : la carte et les polices sont servies par le site. Vos données ne servent jamais à autre chose qu'au service lui-même : ni publicité, ni revente, ni entraînement d'intelligence artificielle, ni analyse commerciale.</p>
|
||||
<h2>1. Responsable du traitement</h2>
|
||||
<p>Le responsable du traitement est <b>Théo Gastinel</b>, micro-entreprise (SIRET : <mark class="a-trancher">[À COMPLÉTER]</mark> ; adresse : <mark class="a-trancher">[À COMPLÉTER]</mark>) <mark class="a-trancher">[À VÉRIFIER : sur gastinel.me, le responsable désigné est « Richard GASTINEL, entrepreneur individuel (EI) » ; les deux sites doivent désigner la bonne personne juridique]</mark>.</p>
|
||||
<p>Toute question ou demande relative à vos données s'adresse par écrit à <b><a href="mailto:studio@gastinel.me">studio@gastinel.me</a></b>. Aucun délégué à la protection des données (DPO) n'a été désigné, la structure n'y étant pas soumise <mark class="a-trancher">[À VÉRIFIER si le forum ouvre à grande échelle]</mark>.</p>
|
||||
<h2>2. Hébergement et transferts</h2>
|
||||
<p>Le site est hébergé par <mark class="a-trancher">[À COMPLÉTER : nom, adresse et pays de l'hébergeur]</mark>. <mark class="a-trancher">[À COMPLÉTER : si l'hébergeur est Infomaniak (Suisse), comme pour gastinel.me, reprendre la mention : la Suisse bénéficie d'une décision d'adéquation de la Commission européenne (art. 45 RGPD).]</mark></p>
|
||||
<p>Aucune donnée personnelle n'est transférée hors de l'Union européenne ou d'un pays reconnu adéquat. Les données de stations sont récupérées par le serveur du site auprès des sources (Météo-France, Infoclimat, WeatherLink) : votre navigateur n'entre jamais en contact avec elles, et elles ne reçoivent aucune information vous concernant.</p>
|
||||
<h2>3. Journaux techniques du serveur</h2>
|
||||
<p><b>Ce qui est enregistré</b>, pour chaque requête : la date et l'heure, l'adresse IP, la page ou le fichier demandé, le code de réponse du serveur <mark class="a-trancher">[À VÉRIFIER : le navigateur (« user-agent ») est-il aussi journalisé ? Le mentionner le cas échéant]</mark>.</p>
|
||||
<p><b>Finalité</b> : assurer la sécurité et le bon fonctionnement du site (détection des attaques et abus, diagnostic des pannes).</p>
|
||||
<p><b>Base légale</b> : intérêt légitime de l'éditeur à sécuriser son service (art. 6-1-f RGPD).</p>
|
||||
<p><b>Durée</b> : les journaux bruts sont supprimés automatiquement au bout de <b>six (6) mois</b>, comme sur l'ensemble des services Gastinel. <mark class="a-trancher">[À VÉRIFIER : la purge est-elle réellement configurée sur le serveur de vercors.me ?]</mark></p>
|
||||
<p><b>Ce qui n'est pas fait</b> : aucun profil, aucune statistique individuelle, aucun recoupement avec un autre traitement, aucune transmission à des tiers, sauf réquisition d'une autorité judiciaire.</p>
|
||||
<h2>4. Personnalisation (stations favorites, vue habituelle)</h2>
|
||||
<p class="avert"><b>Rédaction provisoire, à choisir entre deux options</b> (voir <code>Points-a-trancher.md</code>, point 1). L'option A est recommandée.</p>
|
||||
<h3>Option A (recommandée) : préférences gardées sur votre appareil</h3>
|
||||
<p>Vos stations favorites et votre vue habituelle (zone et niveau de zoom de la carte) sont enregistrées <b>uniquement dans votre navigateur</b> (stockage local), à votre demande, lorsque vous marquez une station comme favorite. Elles ne sont jamais envoyées au serveur.</p>
|
||||
<p>Ce stockage sert seulement une fonction que vous demandez expressément ; il est à ce titre dispensé de consentement (art. 82 de la loi Informatique et Libertés ; lignes directrices de la CNIL du 17 septembre 2020 sur les traceurs, qui exemptent les traceurs conservant le choix de personnalisation d'interface fait par l'utilisateur). Vous pouvez l'effacer à tout moment depuis le site <mark class="a-trancher">[À COMPLÉTER : bouton « Oublier mes préférences »]</mark> ou en effaçant les données du site dans votre navigateur.</p>
|
||||
<h3>Option B : préférences associées à votre adresse IP (projet de Théo)</h3>
|
||||
<p><b>Ce qui est enregistré</b> : votre adresse IP <mark class="a-trancher">[À VÉRIFIER : de préférence sous forme hachée avec un sel secret]</mark>, associée à vos stations favorites et à votre dernière vue de la carte, ainsi que la date de votre dernière visite.</p>
|
||||
<p><b>Finalité</b> : retrouver vos préférences d'une visite à l'autre sans compte.</p>
|
||||
<p><b>Base légale</b> : votre <b>consentement</b> (art. 6-1-a RGPD), recueilli au moyen d'une question claire au premier usage (« Retenir mes stations sur cet appareil grâce à mon adresse IP ? Oui / Non »), le refus étant aussi simple que l'acceptation et sans conséquence sur l'accès au site. Vous pouvez retirer votre consentement à tout moment <mark class="a-trancher">[À COMPLÉTER : lien « Oublier mes préférences »]</mark>, ce qui efface l'enregistrement.</p>
|
||||
<p><b>Durée</b> : <b>treize (13) mois</b> à compter de votre dernière visite, puis suppression automatique. Ce délai s'inspire de la durée maximale retenue par la CNIL pour les traceurs.</p>
|
||||
<p><b>Limites à connaître</b> : une adresse IP n'identifie pas une personne mais une connexion. Elle est souvent <b>partagée</b> (foyer, entreprise, école, réseau mobile, Wi-Fi public) et souvent <b>changeante</b> (box, téléphone). Vos préférences peuvent donc ne pas être retrouvées, ou être vues par une autre personne utilisant la même connexion. N'acceptez pas cette option sur une connexion partagée.</p>
|
||||
<p><b>Séparation</b> : cet enregistrement est distinct des journaux techniques (section 3) et n'est jamais utilisé à d'autres fins (ni statistiques de fréquentation, ni sécurité, ni profilage).</p>
|
||||
<h2>5. Comptes Gastinel Hub et forum</h2>
|
||||
<p><b>Service non ouvert à ce jour — cette section s'appliquera à compter de l'ouverture des comptes et du forum.</b></p>
|
||||
<table>
|
||||
<tr><th>Traitement</th><th>Données</th><th>Base légale</th><th>Durée</th></tr>
|
||||
<tr><td>Compte (via Gastinel Hub)</td><td>Pseudonyme, adresse e-mail, mot de passe (stocké sous forme chiffrée irréversible), rôle (membre, adhérent météo, modérateur, administrateur), date de création</td><td>Exécution du contrat (conditions d'utilisation, art. 6-1-b)</td><td>Durée du compte, puis suppression <mark class="a-trancher">[À COMPLÉTER : délai après clôture ou après [À COMPLÉTER]</mark> ans d'inactivité]</td></tr>
|
||||
<tr><td>Contributions au forum</td><td>Messages, relevés, photos, date, auteur</td><td>Exécution du contrat (art. 6-1-b)</td><td>Jusqu'à suppression par l'auteur ou la modération</td></tr>
|
||||
<tr><td>Adresse IP des auteurs de contributions</td><td>Adresse IP, date et heure, identifiant du contenu</td><td>Obligation légale de conservation des données d'identification des créateurs de contenus (art. 6-1-c RGPD ; art. 6-II LCEN et décret n° 2021-1362) et intérêt légitime (gestion des abus)</td><td><b>13 mois</b> (projet) <mark class="a-trancher">[À VÉRIFIER : le décret fixe un an ; au-delà, l'intérêt légitime doit être justifié — voir <code>Points-a-trancher.md</code>]</mark></td></tr>
|
||||
<tr><td>Signalements et modération</td><td>Contenu signalé, motif, auteur du signalement (s'il est connecté), décision et motifs</td><td>Intérêt légitime (sécurité du forum) et obligations d'hébergeur (LCEN, DSA)</td><td><mark class="a-trancher">[À COMPLÉTER : 1 an après la décision proposé]</mark></td></tr>
|
||||
</table>
|
||||
<p>Les contributions publiées sont visibles par tous les visiteurs. Les adresses IP, e-mails et signalements ne sont visibles que de l'administrateur <mark class="a-trancher">[À VÉRIFIER : les modérateurs y ont-ils accès ? recommandation : non]</mark>.</p>
|
||||
<p><b>Mineurs</b> : l'inscription est ouverte dès 15 ans, âge à partir duquel un mineur peut consentir seul au traitement de ses données (art. 45 de la loi Informatique et Libertés).</p>
|
||||
<p><b>Suppression du compte</b> : elle entraîne l'effacement du pseudonyme, de l'e-mail et des préférences. Les contributions sont <mark class="a-trancher">[À COMPLÉTER : supprimées / anonymisées en « ancien membre »]</mark>. Les adresses IP d'auteurs restent conservées jusqu'au terme de leur durée légale, uniquement pour répondre à une réquisition judiciaire.</p>
|
||||
<h2>6. Archive des relevés météo</h2>
|
||||
<p>Les relevés des stations sont conservés <b>sans limite de durée</b>. Ce sont des mesures physiques (température, humidité, vent, pluie), pas des données personnelles. <mark class="a-trancher">[À VÉRIFIER : une station privée installée chez un particulier et nommée d'après son lieu exact peut révéler une adresse ; nommer ces stations au niveau du hameau ou de la commune.]</mark></p>
|
||||
<h2>7. Destinataires et sous-traitants</h2>
|
||||
<p>Les données personnelles ne sont accessibles qu'à l'éditeur. Elles ne sont ni vendues, ni louées, ni cédées.</p>
|
||||
<table>
|
||||
<tr><th>Sous-traitant</th><th>Rôle</th><th>Localisation</th></tr>
|
||||
<tr><td><mark class="a-trancher">[À COMPLÉTER : hébergeur]</mark></td><td>Hébergement du serveur</td><td><mark class="a-trancher">[À COMPLÉTER]</mark></td></tr>
|
||||
<tr><td>Gastinel Hub (même éditeur)</td><td>Comptes, à venir</td><td><mark class="a-trancher">[À COMPLÉTER]</mark></td></tr>
|
||||
<tr><td><mark class="a-trancher">[À COMPLÉTER : service d'envoi d'e-mails, si les comptes en envoient]</mark></td><td>E-mails de confirmation</td><td><mark class="a-trancher">[À COMPLÉTER]</mark></td></tr>
|
||||
</table>
|
||||
<p>Les données peuvent être communiquées aux autorités judiciaires ou administratives sur réquisition légale.</p>
|
||||
<h2>8. Cookies et traceurs</h2>
|
||||
<ul>
|
||||
<li><b>Aucun cookie tiers</b>, aucun traceur publicitaire, aucun outil de mesure d'audience, aucune empreinte de navigateur.</li>
|
||||
<li><b>Aucune ressource tierce</b> : carte, polices et scripts sont servis par le site.</li>
|
||||
<li>[Option A] Un stockage local conserve vos préférences d'affichage, à votre demande : il est exempté de consentement (voir section 4).</li>
|
||||
<li>[À venir] Un cookie de session sera nécessaire à la connexion au compte ; strictement nécessaire, il est exempté de consentement.</li>
|
||||
</ul>
|
||||
<p>Aucun bandeau de cookies n'est donc affiché [sauf option B, qui demande votre accord au premier usage].</p>
|
||||
<h2>9. Sécurité</h2>
|
||||
<p>Le site est servi exclusivement en HTTPS <mark class="a-trancher">[À VÉRIFIER]</mark>. Les services sont cloisonnés, les accès d'administration nominatifs et limités, et les données réduites au strict nécessaire, sur le modèle des mesures décrites dans la politique de confidentialité de gastinel.me (art. 32 RGPD).</p>
|
||||
<h2>10. Vos droits</h2>
|
||||
<p>Vous disposez à tout moment des droits suivants, par simple demande écrite à <b><a href="mailto:studio@gastinel.me">studio@gastinel.me</a></b>. Une réponse vous est apportée dans un délai maximal d'un mois.</p>
|
||||
<ul>
|
||||
<li><b>Droit d'accès</b> (art. 15) : savoir si des données vous concernant sont traitées et en obtenir une copie.</li>
|
||||
<li><b>Droit de rectification</b> (art. 16) : faire corriger une donnée inexacte.</li>
|
||||
<li><b>Droit à l'effacement</b> (art. 17) : obtenir la suppression de vos données, sous réserve des obligations légales de conservation (adresses IP des auteurs de contenus).</li>
|
||||
<li><b>Droit à la limitation</b> (art. 18) : obtenir le gel de l'utilisation de vos données.</li>
|
||||
<li><b>Droit à la portabilité</b> (art. 20) : recevoir vos données (préférences, contributions) dans un format lisible par machine, pour les traitements fondés sur le consentement ou le contrat.</li>
|
||||
<li><b>Droit d'opposition</b> (art. 21) : vous opposer, pour des raisons tenant à votre situation, à un traitement fondé sur l'intérêt légitime (journaux techniques).</li>
|
||||
<li><b>Retrait du consentement</b> : à tout moment, sans remettre en cause ce qui a été fait avant.</li>
|
||||
<li><b>Directives post mortem</b> (art. 85 de la loi Informatique et Libertés) : indiquer le sort de vos données après votre décès.</li>
|
||||
</ul>
|
||||
<p>Pour une demande portant sur une adresse IP, indiquez l'adresse concernée et la période : sans compte, c'est le seul moyen de retrouver vos données. Une vérification raisonnable peut être demandée pour éviter qu'une personne obtienne les données d'une autre utilisant la même connexion.</p>
|
||||
<h2>11. Réclamation auprès de la CNIL</h2>
|
||||
<p>Si vous estimez, après nous avoir contactés, que vos droits ne sont pas respectés, vous pouvez introduire une réclamation auprès de la <b>Commission nationale de l'informatique et des libertés (CNIL)</b>, 3 place de Fontenoy, TSA 80715, 75334 Paris Cedex 07 ; téléphone : 01 53 73 22 22 ; www.cnil.fr. La réclamation peut être déposée directement en ligne, sans démarche préalable auprès de nous.</p>
|
||||
<h2>12. Modification de la politique</h2>
|
||||
<p>Cette politique peut évoluer, notamment à l'ouverture des comptes et du forum. La version en ligne fait foi ; sa date figure en tête.</p>
|
||||
</main>
|
||||
<footer class="pied">© Théo Gastinel · <a href="cgu.html">Conditions d'utilisation</a> · <a href="confidentialite.html">Confidentialité</a> · <a href="./">Retour à la carte</a></footer>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,117 @@
|
||||
# Carte SVG du Vercors : relief IGN RGE ALTI (courbes + teintes) et rivières OSM.
|
||||
# Unité SVG = 100 m. Origine : coin nord-ouest de la grille.
|
||||
import json, math
|
||||
import numpy as np
|
||||
import contourpy
|
||||
|
||||
LAT0, LAT1, LON0, LON1 = 44.66, 45.31, 5.12, 5.82
|
||||
H, W = 1560, 1200
|
||||
z = np.fromfile('mnt.bil', '<f4').reshape(H, W).astype(np.float64)
|
||||
|
||||
K = math.cos(math.radians((LAT0 + LAT1) / 2))
|
||||
M = 1113.2 # unités (100 m) par degré de latitude
|
||||
VW = round((LON1 - LON0) * K * M, 1)
|
||||
VH = round((LAT1 - LAT0) * M, 1)
|
||||
|
||||
def proj(lon, lat):
|
||||
return ((lon - LON0) * K * M, (LAT1 - lat) * M)
|
||||
|
||||
def blur(a, s):
|
||||
r = int(3 * s)
|
||||
k = np.exp(-0.5 * (np.arange(-r, r + 1) / s) ** 2); k /= k.sum()
|
||||
p = np.pad(a, r, mode='edge')
|
||||
p = np.apply_along_axis(lambda v: np.convolve(v, k, 'valid'), 0, p)
|
||||
p = np.apply_along_axis(lambda v: np.convolve(v, k, 'valid'), 1, p)
|
||||
return p
|
||||
|
||||
zs = blur(z, 1.5)
|
||||
X = (np.arange(W) + 0.5) / W * VW
|
||||
Y = (np.arange(H) + 0.5) / H * VH
|
||||
|
||||
def rdp(pts, eps):
|
||||
if len(pts) < 3:
|
||||
return pts
|
||||
a, b = pts[0], pts[-1]
|
||||
d = b - a
|
||||
n = math.hypot(*d)
|
||||
if n == 0:
|
||||
dist = np.hypot(*(pts - a).T)
|
||||
else:
|
||||
dist = np.abs(d[0] * (pts[:, 1] - a[1]) - d[1] * (pts[:, 0] - a[0])) / n
|
||||
i = int(np.argmax(dist))
|
||||
if dist[i] > eps:
|
||||
return np.vstack([rdp(pts[:i + 1], eps)[:-1], rdp(pts[i:], eps)])
|
||||
return np.array([a, b])
|
||||
|
||||
def f(v):
|
||||
s = f'{v:.1f}'
|
||||
return s[:-2] if s.endswith('.0') else s
|
||||
|
||||
def path(lines, eps, closed=False, minlen=3):
|
||||
out = []
|
||||
for p in lines:
|
||||
if len(p) < minlen:
|
||||
continue
|
||||
s = rdp(np.asarray(p), eps)
|
||||
if len(s) < 2 or (closed and len(s) < 4):
|
||||
continue
|
||||
out.append('M' + 'L'.join(f'{f(x)} {f(y)}' for x, y in s) + ('Z' if closed else ''))
|
||||
return ''.join(out)
|
||||
|
||||
gen = contourpy.contour_generator(X, Y, zs, fill_type='OuterOffset', line_type='Separate')
|
||||
|
||||
# teintes hypsométriques : on empile « z >= seuil »
|
||||
teintes = []
|
||||
for t in (500, 900, 1300, 1700, 2000, 2200):
|
||||
polys, offs = gen.filled(t, 1e5)
|
||||
rings = []
|
||||
for pts, off in zip(polys, offs):
|
||||
for a, b in zip(off[:-1], off[1:]):
|
||||
if b - a >= 8:
|
||||
rings.append(pts[a:b])
|
||||
teintes.append([t, path(rings, 0.2, closed=True, minlen=8)])
|
||||
|
||||
courbes, maitresses = [], []
|
||||
for t in range(200, 2400, 100):
|
||||
lines = [l for l in gen.lines(t) if len(l) >= 6]
|
||||
d = path(lines, 0.15)
|
||||
(maitresses if t % 500 == 0 else courbes).append(d)
|
||||
|
||||
# cours d'eau : IGN BD TOPO (WFS Géoplateforme)
|
||||
grandes = {"l'Isère", 'le Drac', 'la Drôme', 'la Romanche'}
|
||||
petites = {'la Bourne', 'la Vernaison', 'la Lyonne', 'le Méaudret', "l'Adouin", 'le Bès', 'la Roanne',
|
||||
'la Gresse', 'le Furon', 'le Cholet', 'la Vence', 'le Merdaret', 'la Sure'}
|
||||
rivieres = {}
|
||||
for ft in json.load(open('ce.json', encoding='utf-8'))['features']:
|
||||
n = ft['properties']['toponyme']
|
||||
if n in grandes or n in petites:
|
||||
for ligne in ft['geometry']['coordinates']:
|
||||
rivieres.setdefault(n, []).append(np.array([proj(lo, la) for lo, la, *_ in ligne]))
|
||||
riv_g = path([p for n, ps in rivieres.items() if n in grandes for p in ps], 0.4, minlen=2)
|
||||
riv_p = path([p for n, ps in rivieres.items() if n in petites for p in ps], 0.4, minlen=2)
|
||||
|
||||
def alti(lon, lat):
|
||||
i = int((LAT1 - lat) / (LAT1 - LAT0) * H); j = int((lon - LON0) / (LON1 - LON0) * W)
|
||||
return round(float(z[min(max(i, 0), H - 1), min(max(j, 0), W - 1)]))
|
||||
|
||||
# lieux : mairies (geo.api.gouv.fr) et sommets (BD TOPO, altitude lue sur le RGE ALTI)
|
||||
lieux = {}
|
||||
for d in ('38', '26', '05'):
|
||||
for c in json.load(open(f'com{d}.json', encoding='utf-8')):
|
||||
lo, la = c['mairie']['coordinates']
|
||||
if LON0 <= lo <= LON1 and LAT0 <= la <= LAT1:
|
||||
lieux[c['nom']] = {'lon': lo, 'lat': la, 'type': 'ville' if c.get('population', 0) > 5000 else 'village',
|
||||
'pop': c.get('population', 0)}
|
||||
for ft in json.load(open('oro.json', encoding='utf-8'))['features']:
|
||||
p = ft['properties']
|
||||
if p['nature'] in ('Sommet', 'Pic') and p['toponyme']:
|
||||
lo, la = ft['geometry']['coordinates'][:2]
|
||||
lieux.setdefault(p['toponyme'], {'lon': round(lo, 5), 'lat': round(la, 5), 'type': 'peak',
|
||||
'ele': alti(lo, la), 'imp': p['importance']})
|
||||
|
||||
json.dump({'vw': VW, 'vh': VH, 'k': K, 'm': M, 'lon0': LON0, 'lat1': LAT1,
|
||||
'teintes': teintes, 'courbes': ''.join(courbes), 'maitresses': ''.join(maitresses),
|
||||
'riv_g': riv_g, 'riv_p': riv_p, 'lieux': lieux},
|
||||
open('carte.json', 'w', encoding='utf-8'), ensure_ascii=False)
|
||||
print('viewBox', VW, VH, 'courbes', len(''.join(courbes)), 'maitresses', len(''.join(maitresses)),
|
||||
'riv', len(riv_g) + len(riv_p), 'teintes', [len(d) for _, d in teintes])
|
||||
@@ -0,0 +1,31 @@
|
||||
# Courbes de niveau légères, une par altitude, pour l'animation d'ouverture (du plus haut au plus bas).
|
||||
import json, math
|
||||
import numpy as np
|
||||
import contourpy
|
||||
from pnr import rdp, f
|
||||
|
||||
c = json.load(open('carte.json', encoding='utf-8'))
|
||||
LAT0, LAT1, LON0, LON1 = 44.66, 45.31, 5.12, 5.82
|
||||
H, W = 1560, 1200
|
||||
z = np.fromfile('mnt.bil', '<f4').reshape(H, W).astype(np.float64)
|
||||
# sous-échantillonnage ×3 puis léger lissage : traits simples, fichier petit
|
||||
z = z[::3, ::3]
|
||||
k = np.exp(-0.5 * (np.arange(-3, 4) / 1.2) ** 2); k /= k.sum()
|
||||
for ax in (0, 1):
|
||||
z = np.apply_along_axis(lambda v: np.convolve(np.pad(v, 3, mode='edge'), k, 'valid'), ax, z)
|
||||
X = (np.arange(z.shape[1]) + 0.5) / z.shape[1] * c['vw']
|
||||
Y = (np.arange(z.shape[0]) + 0.5) / z.shape[0] * c['vh']
|
||||
gen = contourpy.contour_generator(X, Y, z, line_type='Separate')
|
||||
niveaux = []
|
||||
for t in range(2300, 199, -100):
|
||||
d = ''
|
||||
for l in gen.lines(t):
|
||||
if len(l) < 10:
|
||||
continue
|
||||
s = rdp(np.asarray(l), 1.6)
|
||||
if len(s) >= 2:
|
||||
d += 'M' + 'L'.join(f'{f(x)} {f(y)}' for x, y in s)
|
||||
if d:
|
||||
niveaux.append([t, d])
|
||||
json.dump(niveaux, open('intro.json', 'w'))
|
||||
print(len(niveaux), 'niveaux', sum(len(d) for _, d in niveaux) // 1024, 'Ko')
|
||||
@@ -0,0 +1,60 @@
|
||||
# Fond large et léger autour du massif (flouté sur la page) : même projection que carte.json.
|
||||
import json, math
|
||||
import numpy as np
|
||||
import contourpy
|
||||
from pnr import rdp, f
|
||||
|
||||
c = json.load(open('carte.json', encoding='utf-8'))
|
||||
K, M, LON0, LAT1 = c['k'], c['m'], c['lon0'], c['lat1']
|
||||
proj = lambda lon, lat: ((lon - LON0) * K * M, (LAT1 - lat) * M)
|
||||
|
||||
GLAT0, GLAT1, GLON0, GLON1 = 44.00, 46.00, 4.10, 6.80
|
||||
H, W = 1150, 1100
|
||||
z = np.fromfile('large.bil', '<f4').reshape(H, W).astype(np.float64)
|
||||
z[z < -100] = 0 # hors couverture (hors France) : plaine
|
||||
|
||||
def blur(a, s):
|
||||
r = int(3 * s)
|
||||
k = np.exp(-0.5 * (np.arange(-r, r + 1) / s) ** 2); k /= k.sum()
|
||||
p = np.pad(a, r, mode='edge')
|
||||
p = np.apply_along_axis(lambda v: np.convolve(v, k, 'valid'), 0, p)
|
||||
return np.apply_along_axis(lambda v: np.convolve(v, k, 'valid'), 1, p)
|
||||
|
||||
zs = blur(z, 1.8)
|
||||
X = np.array([proj(GLON0 + (j + 0.5) / W * (GLON1 - GLON0), 0)[0] for j in range(W)])
|
||||
Y = np.array([proj(0, GLAT1 - (i + 0.5) / H * (GLAT1 - GLAT0))[1] for i in range(H)])
|
||||
|
||||
def path(lines, eps, closed=False, minlen=3):
|
||||
out = []
|
||||
for p in lines:
|
||||
if len(p) < minlen:
|
||||
continue
|
||||
s = rdp(np.asarray(p), eps)
|
||||
if len(s) < 2 or (closed and len(s) < 4):
|
||||
continue
|
||||
out.append('M' + 'L'.join(f'{f(x)} {f(y)}' for x, y in s) + ('Z' if closed else ''))
|
||||
return ''.join(out)
|
||||
|
||||
gen = contourpy.contour_generator(X, Y, zs, fill_type='OuterOffset', line_type='Separate')
|
||||
teintes = []
|
||||
for t in (500, 900, 1300, 1700, 2000, 2200):
|
||||
polys, offs = gen.filled(t, 1e5)
|
||||
rings = [pts[a:b] for pts, off in zip(polys, offs) for a, b in zip(off[:-1], off[1:]) if b - a >= 6]
|
||||
teintes.append([t, path(rings, 2.2, closed=True, minlen=6)])
|
||||
courbes = path([l for t in range(400, 4800, 400) for l in gen.lines(t) if len(l) >= 8], 2.0)
|
||||
|
||||
# fleuves : tronçons du réseau IGN (BD TOPO), plus de 50 m de large puis 15 à 50 m
|
||||
def troncons(fichier):
|
||||
out = []
|
||||
for ft in json.load(open(fichier, encoding='utf-8'))['features']:
|
||||
g = ft['geometry']
|
||||
for ligne in (g['coordinates'] if g['type'] == 'MultiLineString' else [g['coordinates']]):
|
||||
out.append(np.array([proj(lo, la) for lo, la, *_ in ligne]))
|
||||
return out
|
||||
rivieres = path(troncons('th2.json'), 0.6, minlen=2)
|
||||
moyennes = path(troncons('th.json'), 1.4, minlen=2)
|
||||
|
||||
x0, y0 = proj(GLON0, GLAT1); x1, y1 = proj(GLON1, GLAT0)
|
||||
json.dump({'cadre': [round(x0), round(y0), round(x1 - x0), round(y1 - y0)], 'teintes': teintes,
|
||||
'courbes': courbes, 'rivieres': rivieres, 'moyennes': moyennes}, open('large.json', 'w', encoding='utf-8'))
|
||||
print('large', [len(d) for _, d in teintes], len(courbes), len(rivieres), len(moyennes))
|
||||
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1 @@
|
||||
[[2300, "M550.5 661.9L545 668.5L540.7 667.2L544.1 654.7L550.5 647.4"], [2200, "M550.5 665.3L545 670.6L538.1 671.8L537.1 670L542.8 654.7L550.5 644.9M550.5 702.3L544.8 703.4L550.5 698.9"], [2100, "M317.1 485L321.5 490.5L319 496.4L317.1 485M550.5 669.5L546.4 673.2L539.5 674.5L535 671.4L541.4 654.7L550.5 643M550.5 704.8L536.7 710.6L533.4 707.6L550.5 697.3"], [2000, "M358.2 336.1L360.3 335.4L362.1 338.8L359 344.3L343.4 341.6L347.9 337L358.2 336.1M315.9 480.8L321.5 486.3L323.5 496.1L317.6 499.4L314.7 489.1L315.9 480.8M550.5 677.2L536.7 675.8L533.6 671.4L540 654.7L550.5 641.5M550.5 707.5L543.4 709L536.7 715.2L531.5 707.6L550.5 696M527.3 722.9L529.8 719.7L533.8 722.9"], [1900, "M354.6 323.5L359 329.3L362.7 323.5L366.2 323.5L361.2 344.4L359 345.8L349.3 342.8L338.3 346.9L336 341.6L352.1 332.6L354.6 323.5M329.4 352.8L331.3 354.1L327.3 359.2L329.4 352.8M313.5 420.9L315.2 433.5L312.1 438.5L313.5 420.9M314.4 447.4L318.6 457.1L316.4 464.1L319.4 469.6L317.8 476.6L325.6 496.1L317.6 502.4L315 500.3L313 489.1L316 476.6L312.4 454.3L314.4 447.4M314.7 514.2L320.4 516.8L317.4 522.5L313.5 522.6L311.6 519.7L314.7 514.2M319 523.9L321.9 523.9L320.4 528.1L319 523.9M336.8 587.9L341.6 593.5L336.8 587.9M326.9 592.1L330 595.7L325.9 595L326.9 592.1M267.9 600.4L269.4 599.3L270.8 603.9L276.8 608.8L276.5 628.3L283.2 640.8L280.4 644.6L274.9 642.9L272.4 638L266 604.6L267.9 600.4M550.5 609.7L546.4 604.6L550.5 593.8M413.2 643.6L415.1 643.6L417.9 653.3L415.5 657.2L413.2 643.6M550.5 679.6L535.6 677L532.4 671.4L539.2 653.3L550.5 639.7M550.5 710.1L544 711.8L549.1 716.5L539.5 717.9L535.9 722.9M526.3 722.9L527.5 718.7L533 715.9L529.5 706.2L550.5 694.7"], [1800, "M525.5 21.6L528.5 22.8L528.2 27.1L523 31.2L525.5 21.6M391.5 242.8L393.4 246.4L389.7 248.4L391.5 242.8M384.1 258.1L386.6 258.1L386.3 265.1L378.3 278.2L374.3 274.8L379.1 270.7L384.1 258.1M373.8 299.9L361.7 345.7L359 347.1L347.9 344.1L335.5 350.5L320.4 375.4L319.5 369.5L325.4 354.1L334.2 348.6L332.8 340.4L345.8 331.9L354.8 317.6L359 321.1L364.5 319.5L373.8 299.9M320.1 377.8L323 382L316.4 400.1L316.7 432.1L314.5 443.2L320 455.7L318.6 464.1L321.6 482.2L327.2 494.7L318 508.6L322.4 512.8L324.4 523.9L321.6 533.7L317.6 536.6L306.4 532.3L304.7 522.5L313.1 503L310.9 487.7L313.1 476.6L311.1 443.2L308.3 426.5L311.7 412.6L310.9 405.6L315.8 400.1L320.1 377.8M293.9 547.6L296.4 549L294.2 552.5L293.9 547.6M543.2 549L545 547.9L546.3 554.5L542.6 553.1L543.2 549M326.7 562.9L335.2 565.7L338 574L336 581L345.7 594.9L342.4 600.7L328.6 600.4L329.1 606L324.5 609.9L317.6 593.5L318.5 582.4L311.4 575.4L313.2 567.1L317.6 569.1L326.7 562.9M270.4 590.7L273.8 590.7L279 607.9L279.9 626.9L286.4 640.8L284.6 647L273.3 643.6L269.6 633.8L264.4 604.6L270.4 590.7M550.5 611.5L543 604.6L546.7 600.4L546.8 594.9L550.5 591.8M387.7 632.5L390 635.2L385.2 637.5L384.7 633.8L387.7 632.5M412.3 640.8L419.9 640.8L417.4 646.4L420 654.7L416.8 663.1L414.1 664.1L410.4 643.6L412.3 640.8M550.5 719.7L540.9 720.3L538.4 722.9M525.1 722.9L526.7 717.3L531.4 714.6L525.9 706.2L530.4 702L538.9 700.6L550.2 692.3L546.9 688.1L547.8 682.1L534 677.9L530.9 672.8L536.9 660.3L537.3 653.3L542.5 649.2L550.5 635.1"], [1700, "M456.6 7.7L459.4 7.7L456.8 18.6L453.5 14.6L456.6 7.7M525.1 20.2L529.2 20.2L529.3 28.5L521.6 33.5L519.6 29.9L525.1 20.2M406.1 177.4L408.6 177.5L410.5 183L404.4 191.6L406.1 177.4M395.7 222L395 247L388.2 252.6L387.8 265.1L376.9 284.7L371.6 273.4L380.6 263.7L382.8 256.7L387.4 254L385.9 247L390.6 230.3L395.7 222M375.3 290.1L375.5 305.8L362.3 347.2L359 348.5L349.3 345.1L342.4 348.1L330.2 359.7L322.8 375L324.4 383.4L318.7 401.5L316.4 441.8L321.7 455.7L323.1 481.4L328.8 493.3L320.4 507.2L324.7 511.4L326.2 523.9L322.5 535L314.9 541.7L299.7 540.9L299.9 553.1L291.4 558.8L285.7 551.7L295.1 537.8L294.2 527.5L301.1 520.9L307.8 503L307.3 480.8L310.2 469.6L303.4 426.5L306.8 412.6L305.6 405.6L311.8 395.9L312.1 386.4L315.5 382L315.9 368.1L323.5 352.8L329 347.2L330 339.8L340.9 330.5L353.5 313.7L363.1 316.4L369 308.2L375.3 290.1M550.5 343.7L550.5 330.3M471.5 447.4L475.4 448.8L473.3 453L471.5 447.4M337.8 521.1L341.6 522.5L336.9 526.4L334.9 523.9L337.8 521.1M543.5 543.4L548 550.4L546.4 557.1L540.8 553.1L543.5 543.4M323.7 558.7L337.5 564.3L337.2 569.8L342.2 575.4L341.3 581L347.8 596.3L339.7 607.4L334.2 604.1L325.9 612.2L316.3 613.6L310.7 606.2L301 600.4L306.4 594.9L305.2 589.3L308.3 583.8L308.8 567.1L313.5 562.8L320.4 563.5L323.7 558.7M269.1 567.1L272.4 567.1L272.2 570.6L268.9 569.8L269.1 567.1M269.4 586.5L276.8 587.9L285.8 635.2L290.1 645L300.7 656.1L301.1 660.7L270.8 641.7L263.3 604.6L269.4 586.5M291.3 603.2L295.6 606L294.2 611.8L290 607.4L291.3 603.2M392 617.1L394.8 616L399.9 618.5L398.9 624.1L393.1 621.3L392 617.1M386.1 631.1L393.8 632.5L392.5 636.6L383.8 641.1L378 638L386.1 631.1M417.6 638L422.9 640.8L419.8 647.8L422.5 654.7L419.6 664.5L411.3 667.3L409.9 649.2L404.7 642.2L417.6 638M458.6 645L461.7 645L460.9 649.5L458.2 648.2L458.6 645M484.1 664.5L492.6 667.1L502.3 683.5L487.7 682.5L489.9 677L484 671.4L484.1 664.5M498 722.9L502.3 720.5L508.3 722.9M523.2 722.9L528.9 713.Ligne tronquée
|
||||
@@ -0,0 +1 @@
|
||||
{"taille": 512, "ox": -803, "oy": -768, "niveaux": [{"L": 0, "s": 1, "i0": 0, "i1": 4, "j0": 0, "j1": 4}, {"L": 1, "s": 2, "i0": 1, "i1": 6, "j0": 1, "j1": 7}, {"L": 2, "s": 4, "i0": 5, "i1": 11, "j0": 5, "j1": 12}, {"L": 3, "s": 8, "i0": 11, "i1": 21, "j0": 11, "j1": 24}], "version": 1793740733}
|
||||
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1,138 @@
|
||||
# UX : polices locales, meta, recherche, filtre vent/pluie, liste cliquable, liens partageables, donnée vieillissante,
|
||||
# accessibilité, footer avec accroche, page À propos.
|
||||
import re
|
||||
ACCROCHE = "Des stations de chez nous, des chiffres d'ici."
|
||||
fontface = open('polices/fontface.css', encoding='utf-8').read()
|
||||
|
||||
p = 'modele.html'
|
||||
s = open(p, encoding='utf-8').read()
|
||||
|
||||
def rep(old, new, count=1):
|
||||
global s
|
||||
assert old in s, old[:80]
|
||||
s = s.replace(old, new, count)
|
||||
|
||||
# 1. polices locales, meta, icône, aucun serveur tiers
|
||||
rep("""<title>Météo Vercors — maquette d'accueil</title>
|
||||
<link rel="preconnect" href="https://fonts.googleapis.com">
|
||||
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
|
||||
<link href="https://fonts.googleapis.com/css2?family=Bitter:ital,wght@0,500;0,600;0,700;1,500&family=Outfit:wght@400;500;600&display=swap" rel="stylesheet">
|
||||
<style>""", """<title>Météo Vercors : la température du Vercors, station par station</title>
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Les températures en direct de 21 stations du Vercors, de Villard-de-Lans à Die : courbes sur 7 jours, vent et pluie.">
|
||||
<meta property="og:title" content="Météo Vercors"><meta property="og:description" content="Le Vercors en direct, station par station.">
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<link rel="preload" href="polices/outfit-normal.woff2" as="font" type="font/woff2" crossorigin>
|
||||
<link rel="preload" href="polices/bitter-normal.woff2" as="font" type="font/woff2" crossorigin>
|
||||
<style>
|
||||
""" + fontface + "\n")
|
||||
rep("<main class=\"carte ouverture\" id=\"carte\">", "<main class=\"carte ouverture\" id=\"carte\" aria-label=\"Carte des stations météo du Vercors\">")
|
||||
|
||||
# 2. cartouche : recherche + filtre
|
||||
rep(' <p class="reseau" id="reseau"></p>', """ <p class="reseau" id="reseau"></p>
|
||||
<div class="outils" id="outils">
|
||||
<div class="rech"><input type="search" id="rech" placeholder="Une station, un village…" autocomplete="off" aria-label="Chercher une station ou un village"><ul id="rech-res" hidden></ul></div>
|
||||
<button type="button" id="filtre" aria-pressed="false" title="Montrer les stations qui mesurent le vent ou la pluie">Vent · pluie</button>
|
||||
</div>""")
|
||||
rep("#retour{display:none;", """.outils{display:flex;gap:8px;margin-top:12px}
|
||||
.rech{position:relative;flex:1;min-width:0}
|
||||
#rech{width:100%;font:inherit;font-size:13.5px;color:var(--roche);background:#fff;border:1px solid var(--roche);border-radius:0;padding:7px 9px;-webkit-appearance:none;appearance:none}
|
||||
#rech::placeholder{color:#8a8f88}
|
||||
#rech-res{position:absolute;left:0;right:0;top:100%;z-index:8;margin:2px 0 0;padding:0;list-style:none;background:#fff;border:1px solid var(--roche);max-height:260px;overflow:auto}
|
||||
#rech-res li{padding:7px 9px;font-size:13.5px;cursor:pointer;border-top:1px solid var(--pierre)}
|
||||
#rech-res li:first-child{border-top:0}
|
||||
#rech-res li.on,#rech-res li:hover{background:#eef2ea}
|
||||
#rech-res small{color:var(--gris);margin-left:6px}
|
||||
#filtre{font:inherit;font-size:11.5px;font-weight:600;letter-spacing:.08em;text-transform:uppercase;color:var(--sapin);background:#fff;border:1px solid var(--sapin);border-radius:0;padding:7px 9px;cursor:pointer;white-space:nowrap}
|
||||
#filtre[aria-pressed=true]{background:var(--sapin);color:#fff}
|
||||
.carte.filtre .puce > button.sans{opacity:.2}
|
||||
.puce .ics{display:none;margin-left:6px;vertical-align:1px}
|
||||
.carte.filtre .puce .ics{display:inline}
|
||||
a:focus-visible,button:focus-visible,input:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
.vieux{color:var(--chaud)!important}
|
||||
#retour{display:none;""")
|
||||
rep(" .cartouche.replie #retour{display:none}", " .cartouche.replie #retour,.cartouche.replie .outils{display:none}")
|
||||
|
||||
# 3. puces : icônes de capteurs (affichées avec le filtre) et état « sans capteur »
|
||||
rep(" const hb = `<span class=\"val\" style=\"color:${couleur(r.t)}\">${fmt(r.t)}</span>${autres ? `<span class=\"n\">+${autres}</span>` : ''}<span class=\"nom\">${p.titre}</span>`;",
|
||||
" const cap = st.some(x => SEM[x.id] && SEM[x.id].pluie), vent = st.some(x => SEM[x.id] && SEM[x.id].vent);\n"
|
||||
" p.b.classList.toggle('sans', !cap && !vent);\n"
|
||||
" const hb = `<span class=\"val\" style=\"color:${couleur(r.t)}\">${fmt(r.t)}</span>${autres ? `<span class=\"n\">+${autres}</span>` : ''}<span class=\"nom\">${p.titre}<span class=\"ics\">${cap ? IC_GOUTTE : ''}${vent ? IC_EOLIENNE : ''}</span></span>`;")
|
||||
|
||||
# 4. liste cliquable vers le plein écran
|
||||
rep(""" return `<a class="case${s.exemple ? ' ex' : ''}" href="#"><small>""", """ return `<button type="button" class="case${s.exemple ? ' ex' : ''}" data-id="${id}"><small>""")
|
||||
rep("""<b style="color:${couleur(s.t)}">${fmt(s.t)}</b></a>`;
|
||||
}).join('')}</div>`).join('');""", """<b style="color:${couleur(s.t)}">${fmt(s.t)}</b></button>`;
|
||||
}).join('')}</div>`).join('');""")
|
||||
rep(".case{border-right:1px solid var(--roche);border-bottom:1px solid var(--roche);padding:12px 14px;text-decoration:none;background:#faf9f5}",
|
||||
".case{font:inherit;color:inherit;text-align:left;cursor:pointer;border:0;border-radius:0;border-right:1px solid var(--roche);border-bottom:1px solid var(--roche);padding:12px 14px;text-decoration:none;background:#faf9f5}")
|
||||
rep("listeStations();\n", "listeStations();\ndocument.getElementById('secteurs').addEventListener('click', ev => {\n const c = ev.target.closest('.case'); if (c && STATIONS[c.dataset.id]) ouvrirPlein([c.dataset.id], c.dataset.id);\n});\n")
|
||||
|
||||
# 5. adresse partageable : #station=<id> ouvre le plein écran
|
||||
rep(" if (!deja) { history.pushState({plein: 1}, ''); requestAnimationFrame(() => plein.classList.add('vu')); }",
|
||||
" if (!deja) { history.pushState({plein: 1}, '', '#station=' + id); requestAnimationFrame(() => plein.classList.add('vu')); }\n else history.replaceState({plein: 1}, '', '#station=' + id);")
|
||||
rep("function masquerPlein(){", "function masquerPlein(){\n if (location.hash.startsWith('#station=')) history.replaceState(null, '', location.pathname + location.search);")
|
||||
rep("// ouverture : les courbes se tracent", "// lien direct vers une station : #station=autrans\nfunction ouvrirDepuisAdresse(){\n const m = location.hash.match(/^#station=([\\w-]+)/);\n if (m && STATIONS[m[1]] && plein.hidden) ouvrirPlein([m[1]], m[1]);\n}\naddEventListener('hashchange', ouvrirDepuisAdresse);\n\n// ouverture : les courbes se tracent")
|
||||
rep("Promise.race([chargerDonnees(), new Promise(r => setTimeout(r, 1500))]).then(ouverture);",
|
||||
"Promise.race([chargerDonnees(), new Promise(r => setTimeout(r, 1500))]).then(() => { ouverture(); ouvrirDepuisAdresse(); });")
|
||||
|
||||
# 6. donnée vieillissante : pancarte en couleur chaude au-delà de 45 minutes
|
||||
rep(" document.getElementById('direct').textContent = `Relevés de ${heureReleve} · ${min < 1 ? 'à l’instant' : `il y a ${min} min`}`;",
|
||||
" const d = document.getElementById('direct');\n d.textContent = `Relevés de ${heureReleve} · ${min < 1 ? 'à l’instant' : min < 120 ? `il y a ${min} min` : `il y a ${Math.round(min / 60)} h`}`;\n d.classList.toggle('vieux', min > 45);")
|
||||
|
||||
# 7. recherche et filtre
|
||||
rep("// téléphone : le cartouche se replie", """// recherche : stations d'abord, puis villages et sommets de la carte
|
||||
const RECH = [];
|
||||
Object.keys(STATIONS).forEach(id => RECH.push({n: STATIONS[id].nom, id, lon: STATIONS[id].lon, lat: STATIONS[id].lat, t: 'station'}));
|
||||
ETIQ.filter(e => ['village', 'ville', 'pic'].includes(e.t)).forEach(e => RECH.push({n: e.n, lon: e.lon, lat: e.lat, t: e.t === 'pic' ? 'sommet' : 'commune'}));
|
||||
const norm = x => x.normalize('NFD').replace(/[\\u0300-\\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
|
||||
const rech = document.getElementById('rech'), resultats = document.getElementById('rech-res');
|
||||
let choixRech = -1;
|
||||
function listerRecherche(){
|
||||
const q = norm(rech.value);
|
||||
const l = q ? RECH.filter(r => norm(r.n).includes(q)).sort((a, b) => (a.t === 'station' ? 0 : 1) - (b.t === 'station' ? 0 : 1)).slice(0, 7) : [];
|
||||
resultats.innerHTML = l.map((r, i) => `<li data-i="${RECH.indexOf(r)}" class="${i === choixRech ? 'on' : ''}">${r.n}<small>${r.t}</small></li>`).join('');
|
||||
resultats.hidden = !l.length;
|
||||
return l;
|
||||
}
|
||||
function allerA(r){
|
||||
resultats.hidden = true; rech.blur(); rech.value = '';
|
||||
fermer();
|
||||
const b = r.id ? boite([r.id]) : [r.lon - 0.05, r.lat + 0.04, r.lon + 0.05, r.lat - 0.04];
|
||||
zoomer(b);
|
||||
if (r.id) setTimeout(() => { const p = puces.find(q => q.ids.includes(r.id) && !q.m.classList.contains('cache')); if (p) ouvrir(p); }, 650);
|
||||
}
|
||||
rech.addEventListener('input', () => { choixRech = -1; listerRecherche(); });
|
||||
rech.addEventListener('keydown', ev => {
|
||||
const l = listerRecherche();
|
||||
if (ev.key === 'ArrowDown') { choixRech = Math.min(l.length - 1, choixRech + 1); listerRecherche(); ev.preventDefault(); }
|
||||
else if (ev.key === 'ArrowUp') { choixRech = Math.max(0, choixRech - 1); listerRecherche(); ev.preventDefault(); }
|
||||
else if (ev.key === 'Enter' && l.length) { allerA(l[Math.max(0, choixRech)]); }
|
||||
else if (ev.key === 'Escape') { resultats.hidden = true; }
|
||||
});
|
||||
resultats.addEventListener('mousedown', ev => { const li = ev.target.closest('li'); if (li) { ev.preventDefault(); allerA(RECH[+li.dataset.i]); } });
|
||||
rech.addEventListener('blur', () => setTimeout(() => { resultats.hidden = true; }, 120));
|
||||
const filtre = document.getElementById('filtre');
|
||||
filtre.addEventListener('click', () => { const on = filtre.getAttribute('aria-pressed') !== 'true'; filtre.setAttribute('aria-pressed', on); carte.classList.toggle('filtre', on); relancer(); });
|
||||
['rech', 'filtre'].forEach(i => document.getElementById(i).addEventListener('click', ev => ev.stopPropagation()));
|
||||
|
||||
// téléphone : le cartouche se replie""")
|
||||
# la barre de recherche ne doit pas déclencher le repli au toucher
|
||||
rep(" if (ev.target.closest('a, button') || carte.clientWidth >= 720) return;", " if (ev.target.closest('a, button, input, .rech') || carte.clientWidth >= 720) return;")
|
||||
|
||||
# 8. footer avec accroche, noscript
|
||||
rep("<footer>Météo Vercors · données : Météo-France (Licence Ouverte), Infoclimat (CC BY ou CC BY-NC selon la station), station Gastinel · fond de carte IGN, licence ouverte</footer>",
|
||||
"""<footer class="pied">
|
||||
<p class="accroche">%s</p>
|
||||
<p>Données : Météo-France (Licence Ouverte), Infoclimat (CC BY ou CC BY-NC selon la station), WeatherLink, station Gastinel. Fond de carte : IGN, licence ouverte.</p>
|
||||
<p><a href="a-propos.html">À propos</a> · <a href="a-propos.html#sources">Sources et licences</a> · <a href="a-propos.html#mentions">Mentions légales</a> · © Théo Gastinel</p>
|
||||
</footer>
|
||||
<noscript><p style="max-width:640px;margin:0 auto;padding:16px;font-family:system-ui">Météo Vercors a besoin de JavaScript pour afficher la carte et les relevés en direct. Les sources et les mentions légales sont sur la page <a href="a-propos.html">À propos</a>.</p></noscript>""" % ACCROCHE)
|
||||
rep("footer{max-width:1080px;margin:0 auto;padding:18px 28px 40px;font-size:12px;color:var(--gris);border-top:1px solid var(--pierre)}",
|
||||
".pied{max-width:1080px;margin:0 auto;padding:22px 28px 44px;font-size:12.5px;color:var(--gris);border-top:1px solid var(--pierre)}\n.pied p{margin:6px 0}\n.pied .accroche{font-family:var(--titre);font-style:italic;font-size:17px;color:var(--sapin)}\n.pied a{color:var(--sapin)}")
|
||||
rep(" footer{padding:16px}", " .pied{padding:18px 16px 36px}")
|
||||
open(p, 'w', encoding='utf-8').write(s)
|
||||
|
||||
a = open('a-propos.html', encoding='utf-8').read().replace('/*POLICES*/', fontface).replace('/*ACCROCHE*/', ACCROCHE)
|
||||
open('a-propos-build.html', 'w', encoding='utf-8').write(a)
|
||||
print('ok')
|
||||
@@ -0,0 +1,50 @@
|
||||
# Périmètre du Parc naturel régional du Vercors (BD TOPO) et position des noms des fleuves.
|
||||
import json, math
|
||||
import numpy as np
|
||||
|
||||
c = json.load(open('carte.json', encoding='utf-8'))
|
||||
K, M, LON0, LAT1 = c['k'], c['m'], c['lon0'], c['lat1']
|
||||
proj = lambda lon, lat: ((lon - LON0) * K * M, (LAT1 - lat) * M)
|
||||
|
||||
def rdp(pts, eps):
|
||||
if len(pts) < 3:
|
||||
return pts
|
||||
a, b = pts[0], pts[-1]
|
||||
d = b - a
|
||||
n = math.hypot(*d)
|
||||
dist = np.hypot(*(pts - a).T) if n == 0 else np.abs(d[0] * (pts[:, 1] - a[1]) - d[1] * (pts[:, 0] - a[0])) / n
|
||||
i = int(np.argmax(dist))
|
||||
if dist[i] > eps:
|
||||
return np.vstack([rdp(pts[:i + 1], eps)[:-1], rdp(pts[i:], eps)])
|
||||
return np.array([a, b])
|
||||
|
||||
f = lambda v: (f'{v:.1f}')[:-2] if f'{v:.1f}'.endswith('.0') else f'{v:.1f}'
|
||||
|
||||
if __name__ == '__main__':
|
||||
parc = next(x for x in json.load(open('parcs.json', encoding='utf-8'))['features']
|
||||
if x['properties']['toponyme'] == 'Parc Naturel Régional du Vercors')
|
||||
d = ''
|
||||
for poly in parc['geometry']['coordinates']:
|
||||
for ring in poly:
|
||||
pts = np.array([proj(lo, la) for lo, la, *_ in ring])
|
||||
s = rdp(pts, 0.4)
|
||||
if len(s) >= 4:
|
||||
d += 'M' + 'L'.join(f'{f(x)} {f(y)}' for x, y in s) + 'Z'
|
||||
|
||||
# nom de chaque fleuve posé sur son cours, au plus près d'un point choisi
|
||||
cibles = {"l'Isère": ('Isère', 5.45, 45.215), 'le Drac': ('Drac', 5.70, 45.06), 'la Drôme': ('Drôme', 5.30, 44.74)}
|
||||
fleuves = []
|
||||
for ft in json.load(open('ce.json', encoding='utf-8'))['features']:
|
||||
n = ft['properties']['toponyme']
|
||||
if n in cibles:
|
||||
nom, lo0, la0 = cibles[n]
|
||||
for ligne in ft['geometry']['coordinates']:
|
||||
for lo, la, *_ in ligne:
|
||||
dd = math.hypot((lo - lo0) * K, la - la0)
|
||||
fleuves.append((dd, nom, lo, la))
|
||||
noms = {}
|
||||
for dd, nom, lo, la in sorted(fleuves):
|
||||
noms.setdefault(nom, {'n': nom, 'lon': round(lo, 5), 'lat': round(la, 5), 'p': 1, 't': 'fleuve'})
|
||||
|
||||
json.dump({'pnr': d, 'fleuves': list(noms.values())}, open('pnr.json', 'w', encoding='utf-8'), ensure_ascii=False)
|
||||
print('pnr', len(d), list(noms.values()))
|
||||
Fichier binaire non affiché.
Fichier binaire non affiché.
@@ -0,0 +1,3 @@
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(polices/bitter-italic.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Bitter';font-style:normal;font-weight:500 700;font-display:swap;src:url(polices/bitter-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Outfit';font-style:normal;font-weight:400 600;font-display:swap;src:url(polices/outfit-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
Fichier binaire non affiché.
@@ -0,0 +1,39 @@
|
||||
# Joue un scénario dans Edge sans affichage : python scenario.py pc|mob URL (étapes dans etapes.json : [[js, attente_s, fichier|null], ...])
|
||||
import json, subprocess, time, urllib.request, base64, sys, os
|
||||
import websocket
|
||||
EDGE = r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"
|
||||
mode, url = sys.argv[1], sys.argv[2]
|
||||
port = 9340 if mode == 'pc' else 9341
|
||||
proc = subprocess.Popen([EDGE, '--headless=new', '--hide-scrollbars', f'--remote-debugging-port={port}',
|
||||
'--user-data-dir=' + os.path.abspath('profil-sc-' + mode), 'about:blank'])
|
||||
try:
|
||||
for _ in range(50):
|
||||
try:
|
||||
page = next(t for t in json.load(urllib.request.urlopen(f'http://127.0.0.1:{port}/json')) if t['type'] == 'page'); break
|
||||
except Exception:
|
||||
time.sleep(0.2)
|
||||
ws = websocket.create_connection(page['webSocketDebuggerUrl'], timeout=60)
|
||||
n = 0
|
||||
def cmd(method, **params):
|
||||
global n
|
||||
n += 1
|
||||
ws.send(json.dumps({'id': n, 'method': method, 'params': params}))
|
||||
while True:
|
||||
r = json.loads(ws.recv())
|
||||
if r.get('id') == n:
|
||||
return r.get('result', r)
|
||||
if mode == 'pc':
|
||||
cmd('Emulation.setDeviceMetricsOverride', width=1440, height=860, deviceScaleFactor=1, mobile=False)
|
||||
else:
|
||||
cmd('Emulation.setDeviceMetricsOverride', width=390, height=844, deviceScaleFactor=2, mobile=True)
|
||||
cmd('Page.navigate', url=url); time.sleep(5)
|
||||
for js, attente, fichier in json.load(open('etapes.json', encoding='utf-8')):
|
||||
r = cmd('Runtime.evaluate', expression=js, awaitPromise=True, returnByValue=True)
|
||||
v = r.get('result', {}).get('value')
|
||||
if v is not None: print(v)
|
||||
if r.get('exceptionDetails'): print('ERREUR', json.dumps(r['exceptionDetails'])[:400])
|
||||
time.sleep(attente)
|
||||
if fichier:
|
||||
open(fichier, 'wb').write(base64.b64decode(cmd('Page.captureScreenshot')['data']))
|
||||
finally:
|
||||
proc.kill()
|
||||
@@ -0,0 +1,55 @@
|
||||
# Découpe la carte (rendu.html) en images WebP de 512 px à 4 niveaux de zoom, avec Edge sans affichage.
|
||||
import json, os, subprocess, time, urllib.request, base64
|
||||
import websocket
|
||||
|
||||
EDGE = r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"
|
||||
T, M = 512, 8 # taille d'une image ; marge rendue autour (le flou ne doit pas laisser de bord clair)
|
||||
X0, Y0, LW, LH = json.load(open('large.json'))['cadre']
|
||||
# niveau : échelle (px par unité de 100 m) et zone couverte (unités) ; le niveau 0 couvre tout le cadre
|
||||
NIVEAUX = [(0, 1, (X0, Y0, X0 + LW, Y0 + LH)), (1, 2, (-400, -300, 950, 1050)),
|
||||
(2, 4, (-150, -60, 700, 800)), (3, 8, (-70, -20, 590, 775))]
|
||||
|
||||
proc = subprocess.Popen([EDGE, '--headless=new', '--hide-scrollbars', '--remote-debugging-port=9334',
|
||||
'--user-data-dir=' + os.path.abspath('profil-tuiles'), 'about:blank'])
|
||||
try:
|
||||
for _ in range(50):
|
||||
try:
|
||||
page = next(t for t in json.load(urllib.request.urlopen('http://127.0.0.1:9334/json')) if t['type'] == 'page'); break
|
||||
except Exception:
|
||||
time.sleep(0.2)
|
||||
ws = websocket.create_connection(page['webSocketDebuggerUrl'], timeout=120)
|
||||
n = 0
|
||||
def cmd(method, **params):
|
||||
global n
|
||||
n += 1
|
||||
ws.send(json.dumps({'id': n, 'method': method, 'params': params}))
|
||||
while True:
|
||||
r = json.loads(ws.recv())
|
||||
if r.get('id') == n:
|
||||
return r.get('result', r)
|
||||
cmd('Emulation.setDeviceMetricsOverride', width=T + 2 * M, height=T + 2 * M, deviceScaleFactor=1, mobile=False)
|
||||
cmd('Page.navigate', url='file:///' + os.path.abspath('rendu.html').replace(os.sep, '/'))
|
||||
time.sleep(3)
|
||||
manifeste = {'taille': T, 'ox': X0, 'oy': Y0, 'niveaux': []}
|
||||
total = 0
|
||||
for L, s, (xa, ya, xb, yb) in NIVEAUX:
|
||||
i0, i1 = int((xa - X0) * s // T), int((xb - X0) * s // T)
|
||||
j0, j1 = int((ya - Y0) * s // T), int((yb - Y0) * s // T)
|
||||
os.makedirs(f'tuiles/{L}', exist_ok=True)
|
||||
cmd('Runtime.evaluate', expression=f'document.body.dataset.n = "{L}"')
|
||||
for i in range(i0, i1 + 1):
|
||||
for j in range(j0, j1 + 1):
|
||||
x, y = X0 + i * T / s, Y0 + j * T / s
|
||||
cmd('Runtime.evaluate', expression=f'poser({x - M / s},{y - M / s},{s});'
|
||||
'new Promise(r=>requestAnimationFrame(()=>requestAnimationFrame(r)))', awaitPromise=True)
|
||||
img = cmd('Page.captureScreenshot', format='webp', quality=82,
|
||||
clip={'x': M, 'y': M, 'width': T, 'height': T, 'scale': 1})
|
||||
open(f'tuiles/{L}/{i}_{j}.webp', 'wb').write(base64.b64decode(img['data']))
|
||||
total += 1
|
||||
manifeste['niveaux'].append({'L': L, 's': s, 'i0': i0, 'i1': i1, 'j0': j0, 'j1': j1})
|
||||
print('niveau', L, (i1 - i0 + 1) * (j1 - j0 + 1), 'images', flush=True)
|
||||
manifeste['version'] = int(time.time()) # dans l'adresse des images : un nouveau rendu n'est jamais pris dans le cache
|
||||
json.dump(manifeste, open('tuiles/manifeste.json', 'w'))
|
||||
print('total', total)
|
||||
finally:
|
||||
proc.kill()
|
||||
@@ -0,0 +1,79 @@
|
||||
"""Tests de l'archive, sans réseau : python -I tests/test_archive.py"""
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import archiver_historique as ar # noqa: E402
|
||||
import collecter_weatherlink as wl # noqa: E402
|
||||
|
||||
BASE = 1793779200 # 2026-11-04 08:00:00 UTC (heure pile)
|
||||
|
||||
|
||||
def dh(ts):
|
||||
import datetime as dt
|
||||
return dt.datetime.fromtimestamp(ts, dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
|
||||
|
||||
|
||||
def source(sid, points):
|
||||
return {"stations": {sid: {"releves": [dict(dh_utc=dh(ts), **v) for ts, v in points]}}}
|
||||
|
||||
|
||||
def test_tranches_et_priorite():
|
||||
db = ar.ouvrir(":memory:")
|
||||
ar.ingerer(db, source("bruyeres", [(BASE, {"temperature": 1.0, "humidite": 80.0})]))
|
||||
# même tranche de 10 min, autre source : la température est remplacée, l'humidité absente ne l'efface pas
|
||||
ar.ingerer(db, source("bruyeres", [(BASE + 120, {"temperature": 2.0, "vent_moyen": 5.0})]))
|
||||
t, h, v = db.execute("SELECT t, h, v FROM obs WHERE id = 'bruyeres'").fetchone()
|
||||
assert (t, h, v) == (2.0, 80.0, 5.0)
|
||||
assert db.execute("SELECT COUNT(*) FROM obs").fetchone()[0] == 1
|
||||
|
||||
|
||||
def test_correspondance_mf_et_sans_temperature():
|
||||
db = ar.ouvrir(":memory:")
|
||||
ar.ingerer(db, source("mf-villard", [(BASE, {"temperature": 3.0}), (BASE + 600, {"humidite": 90.0})]), ar.CORRESPONDANCE_MF)
|
||||
assert [r[0] for r in db.execute("SELECT id FROM obs")] == ["villard"]
|
||||
|
||||
|
||||
def test_courbes_capteurs_et_pluie_horaire():
|
||||
db = ar.ouvrir(":memory:")
|
||||
pts = [(BASE + i * 600, {"temperature": float(i % 5), "pluie_1h": 0.4 if i % 6 == 0 else 0.0}) for i in range(36)]
|
||||
ar.ingerer(db, source("autrans", pts))
|
||||
ar.ingerer(db, source("meaudre", [(BASE, {"temperature": 1.0, "vent_moyen": 3.0, "humidite": 90.0})]))
|
||||
cb = ar.courbes(db, BASE + 36 * 600)
|
||||
assert cb["autrans"]["capteurs"] == {"vent": False, "pluie": True, "humidite": False}
|
||||
assert cb["meaudre"]["capteurs"] == {"vent": True, "pluie": False, "humidite": True}
|
||||
assert len(cb["autrans"]["t"]) == 7 * 48 + 1 and cb["autrans"]["pas"] == 1800
|
||||
r = [x for x in cb["autrans"]["r"] if x is not None]
|
||||
assert 0.4 in r # pluie relevée à l'heure pile
|
||||
|
||||
|
||||
def test_ecriture_publique(tmp="test-archive-sortie"):
|
||||
import json
|
||||
import shutil
|
||||
db = ar.ouvrir(":memory:")
|
||||
ar.ingerer(db, source("die", [(BASE, {"temperature": 1.0})]))
|
||||
try:
|
||||
idx = ar.ecrire(tmp, BASE + 600, db)
|
||||
assert idx["die"]["pluie"] is False and os.path.exists(os.path.join(tmp, "die.json"))
|
||||
wl.verifier_public({"stations": {}})
|
||||
texte = open(os.path.join(tmp, "die.json"), encoding="utf-8").read()
|
||||
assert "/home" not in texte and json.loads(texte)["id"] == "die"
|
||||
finally:
|
||||
shutil.rmtree(tmp, ignore_errors=True)
|
||||
|
||||
|
||||
def test_alleger_weatherlink():
|
||||
maintenant = wl.maintenant()
|
||||
rel = [{"dh_utc": wl.fmt_utc(maintenant - wl.dt.timedelta(minutes=m)), "temperature": 1.0} for m in range(0, 300)]
|
||||
out = wl.alleger(rel, maintenant)
|
||||
assert len(out) < 60 and out[-1]["dh_utc"] == rel[0]["dh_utc"] # le plus récent est gardé
|
||||
assert len({r["dh_utc"] for r in out}) == len(out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
n = 0
|
||||
for nom, f in list(globals().items()):
|
||||
if nom.startswith("test_") and callable(f):
|
||||
f()
|
||||
n += 1
|
||||
print("%d tests OK" % n)
|
||||
@@ -0,0 +1,52 @@
|
||||
"""Tests de l'extraction Infoclimat, sans réseau : python -I tests/test_infoclimat.py"""
|
||||
import datetime as dt
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import extraire_infoclimat as ic # noqa: E402
|
||||
from collecter_weatherlink import verifier_public # noqa: E402
|
||||
|
||||
FIN = dt.datetime(2026, 11, 3, 21, 50, tzinfo=dt.timezone.utc)
|
||||
|
||||
|
||||
def rel(min_avant, t, **k):
|
||||
d = FIN - dt.timedelta(minutes=min_avant)
|
||||
r = {"dh_utc": d.strftime("%Y-%m-%d %H:%M:%S"), "temperature": t, "humidite": None, "pression": 1024.0}
|
||||
r.update(k)
|
||||
return r
|
||||
|
||||
|
||||
def source(releves_t0, releves_ia=None):
|
||||
return {"stations": {"000T0": {"nom": "Lans – Bruyères", "releves": releves_t0},
|
||||
"000IA": {"nom": "Méaudre", "releves": releves_ia or []}},
|
||||
"metadonnees": {"000T0": {"licence": "CC BY"}}}
|
||||
|
||||
|
||||
def test_fenetre_ordre_vides_minmax():
|
||||
obj, _ = ic.extraire(source([rel(10, -2.1), rel(30 * 60, 9.0), rel(20, -1.0, humidite=91)]), FIN)
|
||||
r = obj["stations"]["bruyeres"]["releves"]
|
||||
assert [x["temperature"] for x in r] == [-1.0, -2.1] # plus de 24 h écarté, ordre croissant
|
||||
assert "humidite" not in r[-1] and r[0]["humidite"] == 91 # pas de valeur vide
|
||||
assert r[-1]["temperature_min"] == -2.1 and r[-1]["temperature_max"] == -1.0
|
||||
assert not obj["stations"]["bruyeres"]["hors_ligne"]
|
||||
|
||||
|
||||
def test_hors_ligne_et_absente():
|
||||
obj, _ = ic.extraire(source([rel(90, 1.0)]), FIN)
|
||||
assert obj["stations"]["bruyeres"]["hors_ligne"]
|
||||
assert obj["stations"]["meaudre"]["hors_ligne"] and obj["stations"]["meaudre"]["releves"] == []
|
||||
|
||||
|
||||
def test_public_propre():
|
||||
obj, _ = ic.extraire(source([rel(10, -2.1)]), FIN)
|
||||
verifier_public(obj)
|
||||
assert obj["metadonnees"]["bruyeres"]["licence"] == "CC BY"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
n = 0
|
||||
for nom, f in list(globals().items()):
|
||||
if nom.startswith("test_") and callable(f):
|
||||
f(); n += 1
|
||||
print("%d tests OK" % n)
|
||||
@@ -0,0 +1,89 @@
|
||||
"""Tests du collecteur Météo-France, sans réseau : python -I tests/test_meteofrance.py"""
|
||||
import datetime as dt
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import collecter_meteofrance as mf # noqa: E402
|
||||
from collecter_weatherlink import verifier_public # noqa: E402
|
||||
|
||||
FIN = dt.datetime(2026, 11, 3, 21, 30, tzinfo=dt.timezone.utc)
|
||||
|
||||
|
||||
def enr(minutes_avant, t=272.15, rr=0.0, **extra):
|
||||
d = FIN - dt.timedelta(minutes=minutes_avant)
|
||||
r = {"geo_id_insee": "38548001", "validity_time": d.strftime("%Y-%m-%dT%H:%M:%SZ"), "t": t, "rr_per": rr,
|
||||
"td": None, "u": None, "ff": None, "raf10": None, "dd": None, "pmer": None}
|
||||
r.update(extra)
|
||||
return r
|
||||
|
||||
|
||||
def test_conversions():
|
||||
p = mf.releve_depuis_mf(enr(0, t=272.15, td=271.15, u=93, ff=2.0, raf10=5.0, dd=250, pmer=101820))
|
||||
assert p["temperature"] == -1.0 and p["point_de_rosee"] == -2.0 and p["humidite"] == 93
|
||||
assert p["vent_moyen"] == 7.2 and p["vent_rafales"] == 18.0 and p["vent_direction"] == 250
|
||||
assert p["pression"] == 1018.2 and p["dh_utc"] == "2026-11-03 21:30:00"
|
||||
|
||||
|
||||
def test_sans_temperature_ignore():
|
||||
assert mf.releve_depuis_mf(enr(0, t=None)) is None
|
||||
|
||||
|
||||
def test_releves_ordre_fenetre_minmax():
|
||||
# l'API renvoie du plus récent au plus ancien, sur plusieurs jours
|
||||
brut = [enr(m, t=273.15 + (m % 50) / 10) for m in range(0, 5 * 24 * 60, 6)]
|
||||
rel = mf.construire_releves(brut, FIN, heures=24)
|
||||
assert len(rel) == 240 and rel[0]["dh_utc"] < rel[-1]["dh_utc"]
|
||||
ts = [r["temperature"] for r in rel]
|
||||
assert rel[-1]["temperature_min"] == min(ts) and rel[-1]["temperature_max"] == max(ts)
|
||||
|
||||
|
||||
def test_pluie_glissante_et_depuis_minuit():
|
||||
brut = [enr(m, rr=0.2) for m in range(0, 180, 6)] # 0,2 mm toutes les 6 min pendant 3 h
|
||||
rel = mf.construire_releves(brut, FIN, heures=24)
|
||||
assert rel[-1]["pluie_1h"] == 2.0 # 10 périodes dans l'heure
|
||||
# minuit à Paris = 23:00 UTC la veille : les 3 h sont dans la journée
|
||||
assert rel[-1]["pluie_cumul_0h"] == round(0.2 * 30, 1)
|
||||
|
||||
|
||||
def test_hors_ligne_et_erreur_sans_cle():
|
||||
cfg = {"stations": {"mf-x": {"id": "1", "nom": "X", "lat": 45.1, "lon": 5.5, "altitude": 1000}}}
|
||||
obj, journal = mf.collecter(cfg, "", pause=0)
|
||||
assert obj["stations"]["mf-x"]["hors_ligne"] and "sans clé" in journal[0]
|
||||
|
||||
def vieux(_id, _cle):
|
||||
return [enr(120)]
|
||||
mf.maintenant = lambda: FIN
|
||||
obj, journal = mf.collecter(cfg, "cle-factice", appel=vieux, pause=0)
|
||||
assert obj["stations"]["mf-x"]["hors_ligne"] and "trop ancien" in journal[0]
|
||||
|
||||
|
||||
def test_json_public_propre():
|
||||
cfg = {"stations": {"mf-x": {"id": "38548001", "nom": "Villard", "lat": 45.0785, "lon": 5.561, "altitude": 1027}}}
|
||||
mf.maintenant = lambda: FIN
|
||||
obj, _ = mf.collecter(cfg, "cle-secrete-123", appel=lambda i, c: [enr(0, u=90)], pause=0)
|
||||
verifier_public(obj)
|
||||
texte = json.dumps(obj, ensure_ascii=False)
|
||||
assert "cle-secrete-123" not in texte and "38548001" not in texte
|
||||
assert not obj["stations"]["mf-x"]["hors_ligne"]
|
||||
|
||||
|
||||
def test_cle_depuis_fichier(tmp="test-mf.env"):
|
||||
with open(tmp, "w", encoding="utf-8") as f:
|
||||
f.write("AUTRE=x\nMF_DPPAQUETOBS_CLE=valeur-test\n")
|
||||
try:
|
||||
os.environ.pop("MF_DPPAQUETOBS_CLE", None)
|
||||
assert mf.lire_cle("MF_DPPAQUETOBS_CLE", tmp) == "valeur-test"
|
||||
assert mf.lire_cle("ABSENTE", tmp) == ""
|
||||
finally:
|
||||
os.remove(tmp)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
n = 0
|
||||
for nom, f in list(globals().items()):
|
||||
if nom.startswith("test_") and callable(f):
|
||||
f()
|
||||
n += 1
|
||||
print("%d tests OK" % n)
|
||||
@@ -0,0 +1,31 @@
|
||||
"""Test de l'import open data : python -I tests/test_opendata.py"""
|
||||
import gzip
|
||||
import os
|
||||
import sqlite3
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import importer_opendata as io # noqa: E402
|
||||
|
||||
|
||||
def test_import(tmp="test-od.csv.gz"):
|
||||
lignes = ["NUM_POSTE;NOM_USUEL;AAAAMMJJHH;T;TN;TX;TD;U;FF;FXI;DD;RR1;PMER;NEIGETOT",
|
||||
"38548001;VILLARD;2026010112;4.4;1.7;4.4;-3.3;58;1.8;3.9;220;0.0;;0",
|
||||
"38548001;VILLARD;2026010113;;;;;;;;;;;",
|
||||
"99999999;AUTRE;2026010112;9.9;;;;;;;;;;"]
|
||||
with gzip.open(tmp, "wt", encoding="utf-8") as f:
|
||||
f.write("\n".join(lignes) + "\n")
|
||||
try:
|
||||
db = sqlite3.connect(":memory:")
|
||||
db.execute(io.SCHEMA)
|
||||
assert io.importer_fichier(db, tmp) == 2 # le poste inconnu est ignoré
|
||||
t, u, p = db.execute("SELECT t, u, pmer FROM horaire WHERE id = 'villard' ORDER BY ts LIMIT 1").fetchone()
|
||||
assert (t, u, p) == (4.4, 58.0, None)
|
||||
assert io.importer_fichier(db, tmp) == 2 and db.execute("SELECT COUNT(*) FROM horaire").fetchone()[0] == 2 # ré-import sans doublon
|
||||
finally:
|
||||
os.remove(tmp)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_import()
|
||||
print("1 test OK")
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Tests de l'extraction VP2, sans réseau : python -I tests/test_vp2.py"""
|
||||
import datetime as dt
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import extraire_vp2 as vp # noqa: E402
|
||||
from collecter_weatherlink import verifier_public # noqa: E402
|
||||
|
||||
BASE = 1793779200 # 2026-11-04 08:00:00 UTC
|
||||
|
||||
|
||||
def l(ts, t=1.0, h=90.0, v=2.0, jour=0.0):
|
||||
return (BASE + ts, {"t": t, "h": h, "p": 1020.0, "v": v, "dir": 200.0, "jour": jour})
|
||||
|
||||
|
||||
def test_tranches_unites_pluie():
|
||||
lignes = [l(0, jour=1.0), l(20, jour=1.0), l(600, jour=1.4), l(1200, jour=1.4), l(1800, jour=1.8)]
|
||||
r = vp.releves(lignes)
|
||||
assert len(r) == 4 # une tranche de 10 minutes chacune
|
||||
assert r[-1]["vent_moyen"] == 7.2 and r[-1]["vent_direction"] == 200 # m/s -> km/h
|
||||
assert r[-1]["pluie_1h"] == 0.8 and r[-1]["pluie_cumul_0h"] == 1.8
|
||||
|
||||
|
||||
def test_remise_a_zero_minuit():
|
||||
r = vp.releves([l(0, jour=5.0), l(600, jour=0.2)])
|
||||
assert r[-1]["pluie_1h"] == 0.2 # cumul du jour reparti à zéro : on ne compte pas −4,8
|
||||
|
||||
|
||||
def test_point_de_rosee_et_hors_ligne():
|
||||
assert abs(vp.point_de_rosee(10.0, 100.0) - 10.0) < 0.01
|
||||
fin = dt.datetime.fromtimestamp(BASE + 7200, dt.timezone.utc)
|
||||
obj = vp.construire([l(0)], fin)
|
||||
assert obj["stations"]["lans"]["hors_ligne"] # dernier relevé vieux de 2 h
|
||||
verifier_public(obj)
|
||||
|
||||
|
||||
def test_aucune_donnee_interieure():
|
||||
obj = vp.construire([l(0)], dt.datetime.fromtimestamp(BASE + 60, dt.timezone.utc))
|
||||
texte = str(obj)
|
||||
assert "int" not in texte.replace("interieur", "") or "temp_int" not in texte
|
||||
assert set(obj["stations"]["lans"]["releves"][0]) <= {"dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
|
||||
"vent_moyen", "vent_direction", "pluie_1h", "pluie_cumul_0h", "temperature_min", "temperature_max"}
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
n = 0
|
||||
for nom, f in list(globals().items()):
|
||||
if nom.startswith("test_") and callable(f):
|
||||
f(); n += 1
|
||||
print("%d tests OK" % n)
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur