651 lines
21 KiB
Python
651 lines
21 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import datetime
|
|
import html
|
|
import json
|
|
import logging
|
|
import os
|
|
import time
|
|
from logging.handlers import RotatingFileHandler
|
|
from typing import Dict, List, Optional, Tuple
|
|
from zoneinfo import ZoneInfo
|
|
|
|
import requests
|
|
from dateutil import parser
|
|
|
|
# =============================================================================
|
|
# SEVERE WEATHER ALERT (next 24h) - Casa (LAT/LON)
|
|
# - Freezing rain/drizzle (WMO codes 56,57,66,67) -> priorità alta, basta 1 occorrenza
|
|
# - Wind gusts persistence: >= soglia per almeno 2 ore consecutive
|
|
# - Rain persistence: soglia (mm/3h) superata per almeno 2 ore (2 finestre 3h consecutive)
|
|
#
|
|
# Telegram token: NOT in clear.
|
|
# Read order:
|
|
# 1) env TELEGRAM_BOT_TOKEN
|
|
# 2) ~/.telegram_dpc_bot_token
|
|
# 3) /etc/telegram_dpc_bot_token
|
|
#
|
|
# Debug:
|
|
# DEBUG=1 python3 severe_weather.py
|
|
#
|
|
# Log:
|
|
# ./weather_alert.log (same folder as this script)
|
|
# =============================================================================
|
|
|
|
DEBUG = os.environ.get("DEBUG", "0").strip() == "1"
|
|
|
|
# ----------------- TELEGRAM -----------------
|
|
TELEGRAM_CHAT_IDS = ["64463169", "24827341", "132455422", "5405962012"]
|
|
TOKEN_FILE_HOME = os.path.expanduser("~/.telegram_dpc_bot_token")
|
|
TOKEN_FILE_ETC = "/etc/telegram_dpc_bot_token"
|
|
|
|
# ----------------- LOCATION -----------------
|
|
LAT = 43.9356
|
|
LON = 12.4296
|
|
|
|
# ----------------- THRESHOLDS -----------------
|
|
# Vento (km/h) - soglie come da tuo set
|
|
WIND_YELLOW = 62.0
|
|
WIND_ORANGE = 75.0
|
|
WIND_RED = 88.0
|
|
|
|
# Pioggia: mm in 3 ore
|
|
RAIN_3H_LIMIT = 25.0
|
|
|
|
# Persistenza minima richiesta (ore)
|
|
PERSIST_HOURS = 2 # richiesta utente: >=2 ore
|
|
|
|
# Freezing rain/drizzle codes
|
|
FREEZING_CODES = {56, 57, 66, 67}
|
|
|
|
# ----------------- HORIZON -----------------
|
|
HOURS_AHEAD = 24
|
|
|
|
# ----------------- FILES -----------------
|
|
STATE_FILE = "/home/daniely/docker/telegram-bot/weather_state.json"
|
|
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
LOG_FILE = os.path.join(BASE_DIR, "weather_alert.log")
|
|
|
|
# ----------------- OPEN-METEO -----------------
|
|
OPEN_METEO_URL = "https://api.open-meteo.com/v1/forecast"
|
|
TZ = "Europe/Rome"
|
|
TZINFO = ZoneInfo(TZ)
|
|
HTTP_HEADERS = {"User-Agent": "rpi-severe-weather/2.0"}
|
|
|
|
# Force model: AROME France HD 1.5 km
|
|
MODEL_PRIMARY = "meteofrance_arome_france_hd"
|
|
# Fallback (stessa famiglia Meteo-France) per continuità operativa
|
|
MODEL_FALLBACK = "meteofrance_seamless"
|
|
|
|
# Se True, invia messaggio "rientrata" quando tutto torna sotto soglia (non è un errore)
|
|
SEND_ALL_CLEAR = True
|
|
|
|
|
|
# =============================================================================
|
|
# LOGGING
|
|
# =============================================================================
|
|
def setup_logger() -> logging.Logger:
|
|
logger = logging.getLogger("severe_weather")
|
|
logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
|
|
logger.handlers.clear()
|
|
|
|
fh = RotatingFileHandler(LOG_FILE, maxBytes=1_000_000, backupCount=5, encoding="utf-8")
|
|
fh.setLevel(logging.DEBUG)
|
|
fmt = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
|
|
fh.setFormatter(fmt)
|
|
logger.addHandler(fh)
|
|
|
|
if DEBUG:
|
|
sh = logging.StreamHandler()
|
|
sh.setLevel(logging.DEBUG)
|
|
sh.setFormatter(fmt)
|
|
logger.addHandler(sh)
|
|
|
|
return logger
|
|
|
|
|
|
LOGGER = setup_logger()
|
|
|
|
|
|
# =============================================================================
|
|
# UTILS
|
|
# =============================================================================
|
|
def ensure_parent_dir(path: str) -> None:
|
|
parent = os.path.dirname(path)
|
|
if parent and not os.path.exists(parent):
|
|
os.makedirs(parent, exist_ok=True)
|
|
|
|
|
|
def now_local() -> datetime.datetime:
|
|
return datetime.datetime.now(TZINFO)
|
|
|
|
|
|
def read_text_file(path: str) -> str:
|
|
try:
|
|
with open(path, "r", encoding="utf-8") as f:
|
|
return f.read().strip()
|
|
except FileNotFoundError:
|
|
return ""
|
|
except PermissionError:
|
|
LOGGER.debug("Permission denied reading %s", path)
|
|
return ""
|
|
except Exception as e:
|
|
LOGGER.exception("Error reading %s: %s", path, e)
|
|
return ""
|
|
|
|
|
|
def load_bot_token() -> str:
|
|
tok = os.environ.get("TELEGRAM_BOT_TOKEN", "").strip()
|
|
if tok:
|
|
return tok
|
|
tok = read_text_file(TOKEN_FILE_HOME)
|
|
if tok:
|
|
return tok
|
|
tok = read_text_file(TOKEN_FILE_ETC)
|
|
return tok.strip() if tok else ""
|
|
|
|
|
|
def parse_time_to_local(t: str) -> datetime.datetime:
|
|
"""
|
|
Robust timezone handling:
|
|
- If timestamps are naive (common when timezone=Europe/Rome), interpret as Europe/Rome.
|
|
- If timestamps include offset, convert to Europe/Rome.
|
|
"""
|
|
dt = parser.isoparse(t)
|
|
if dt.tzinfo is None:
|
|
return dt.replace(tzinfo=TZINFO)
|
|
return dt.astimezone(TZINFO)
|
|
|
|
|
|
def hhmm(dt: datetime.datetime) -> str:
|
|
return dt.strftime("%H:%M")
|
|
|
|
|
|
# =============================================================================
|
|
# TELEGRAM
|
|
# =============================================================================
|
|
def telegram_send_html(message_html: str) -> bool:
|
|
"""
|
|
Never raises. Returns True if at least one chat_id succeeded.
|
|
IMPORTANT: called only on REAL ALERTS (not on errors).
|
|
"""
|
|
token = load_bot_token()
|
|
if not token:
|
|
LOGGER.warning("Telegram token missing: message not sent.")
|
|
return False
|
|
|
|
url = f"https://api.telegram.org/bot{token}/sendMessage"
|
|
base_payload = {
|
|
"text": message_html,
|
|
"parse_mode": "HTML",
|
|
"disable_web_page_preview": True,
|
|
}
|
|
|
|
sent_ok = False
|
|
with requests.Session() as s:
|
|
for chat_id in TELEGRAM_CHAT_IDS:
|
|
payload = dict(base_payload)
|
|
payload["chat_id"] = chat_id
|
|
try:
|
|
resp = s.post(url, json=payload, timeout=15)
|
|
if resp.status_code == 200:
|
|
sent_ok = True
|
|
else:
|
|
LOGGER.error("Telegram error chat_id=%s status=%s body=%s",
|
|
chat_id, resp.status_code, resp.text[:500])
|
|
time.sleep(0.25)
|
|
except Exception as e:
|
|
LOGGER.exception("Telegram exception chat_id=%s err=%s", chat_id, e)
|
|
|
|
return sent_ok
|
|
|
|
|
|
# =============================================================================
|
|
# STATE
|
|
# =============================================================================
|
|
def load_state() -> Dict:
|
|
default = {
|
|
"alert_active": False,
|
|
"wind_level": 0,
|
|
"last_wind_peak": 0.0,
|
|
"last_rain_3h": 0.0,
|
|
"freezing_active": False,
|
|
}
|
|
if os.path.exists(STATE_FILE):
|
|
try:
|
|
with open(STATE_FILE, "r", encoding="utf-8") as f:
|
|
data = json.load(f) or {}
|
|
default.update(data)
|
|
except Exception as e:
|
|
LOGGER.exception("State read error: %s", e)
|
|
return default
|
|
|
|
|
|
def save_state(state: Dict) -> None:
|
|
try:
|
|
ensure_parent_dir(STATE_FILE)
|
|
with open(STATE_FILE, "w", encoding="utf-8") as f:
|
|
json.dump(state, f, ensure_ascii=False, indent=2)
|
|
except Exception as e:
|
|
LOGGER.exception("State write error: %s", e)
|
|
|
|
|
|
# =============================================================================
|
|
# OPEN-METEO
|
|
# =============================================================================
|
|
def fetch_forecast(models_value: str) -> Optional[Dict]:
|
|
params = {
|
|
"latitude": LAT,
|
|
"longitude": LON,
|
|
"hourly": "precipitation,wind_gusts_10m,weather_code",
|
|
"timezone": TZ,
|
|
"forecast_days": 2,
|
|
"wind_speed_unit": "kmh",
|
|
"precipitation_unit": "mm",
|
|
"models": models_value,
|
|
}
|
|
|
|
try:
|
|
r = requests.get(OPEN_METEO_URL, params=params, headers=HTTP_HEADERS, timeout=25)
|
|
if r.status_code == 400:
|
|
# Log reason if present; no Telegram on errors
|
|
try:
|
|
j = r.json()
|
|
LOGGER.error("Open-Meteo 400 (models=%s): %s", models_value, j.get("reason", j))
|
|
except Exception:
|
|
LOGGER.error("Open-Meteo 400 (models=%s): %s", models_value, r.text[:500])
|
|
return None
|
|
r.raise_for_status()
|
|
return r.json()
|
|
except Exception as e:
|
|
LOGGER.exception("Open-Meteo request error (models=%s): %s", models_value, e)
|
|
return None
|
|
|
|
|
|
def get_forecast() -> Tuple[Optional[Dict], str]:
|
|
LOGGER.debug("Requesting Open-Meteo with models=%s", MODEL_PRIMARY)
|
|
data = fetch_forecast(MODEL_PRIMARY)
|
|
if data is not None:
|
|
return data, MODEL_PRIMARY
|
|
|
|
LOGGER.warning("Primary model failed (%s). Trying fallback=%s", MODEL_PRIMARY, MODEL_FALLBACK)
|
|
data2 = fetch_forecast(MODEL_FALLBACK)
|
|
if data2 is not None:
|
|
return data2, MODEL_FALLBACK
|
|
|
|
return None, MODEL_PRIMARY
|
|
|
|
|
|
# =============================================================================
|
|
# PERSISTENCE LOGIC
|
|
# =============================================================================
|
|
def best_wind_persistent_level(
|
|
gusts: List[float],
|
|
times: List[str],
|
|
start_idx: int,
|
|
end_idx: int,
|
|
persist_hours: int
|
|
) -> Tuple[int, float, str, int]:
|
|
"""
|
|
Returns:
|
|
(level, peak_gust_within_level, first_start_hhmm, run_length_hours)
|
|
Level 0 means not persistent above yellow.
|
|
Persistence means >= threshold for >= persist_hours consecutive hourly points.
|
|
"""
|
|
thresholds = [
|
|
(3, WIND_RED),
|
|
(2, WIND_ORANGE),
|
|
(1, WIND_YELLOW),
|
|
]
|
|
|
|
# Convert times to local datetimes once for speed/readability
|
|
dt_list = [parse_time_to_local(t) for t in times]
|
|
|
|
def find_run(threshold: float) -> Tuple[bool, float, str, int]:
|
|
consec = 0
|
|
run_start = None
|
|
run_peak = 0.0
|
|
best_start = ""
|
|
best_peak = 0.0
|
|
best_len = 0
|
|
|
|
for i in range(start_idx, end_idx):
|
|
try:
|
|
v = float(gusts[i])
|
|
except Exception:
|
|
v = 0.0
|
|
|
|
if v >= threshold:
|
|
if consec == 0:
|
|
run_start = i
|
|
run_peak = v
|
|
else:
|
|
run_peak = max(run_peak, v)
|
|
consec += 1
|
|
|
|
# record first qualifying run of required length
|
|
if consec >= persist_hours and run_start is not None:
|
|
# lock the first time a qualifying run appears, but keep peak within that run length
|
|
# Extend peak as the run continues
|
|
# If user prefers "meglio uno in più", we take the first qualifying run.
|
|
if best_len == 0:
|
|
best_start = hhmm(dt_list[run_start])
|
|
best_peak = run_peak
|
|
best_len = consec
|
|
else:
|
|
# If same threshold continues longer, update peak and length
|
|
if run_start == (run_start if best_len else run_start):
|
|
best_peak = max(best_peak, run_peak)
|
|
best_len = max(best_len, consec)
|
|
else:
|
|
consec = 0
|
|
run_start = None
|
|
run_peak = 0.0
|
|
|
|
if best_len >= persist_hours:
|
|
return True, best_peak, best_start, best_len
|
|
return False, 0.0, "", 0
|
|
|
|
for lvl, thr in thresholds:
|
|
ok, peak, start_hhmm, run_len = find_run(thr)
|
|
if ok:
|
|
return lvl, peak, start_hhmm, run_len
|
|
|
|
return 0, 0.0, "", 0
|
|
|
|
|
|
def best_rain_persistent_3h(
|
|
rain: List[float],
|
|
times: List[str],
|
|
start_idx: int,
|
|
end_idx: int,
|
|
limit_3h: float,
|
|
persist_hours: int
|
|
) -> Tuple[float, str, int]:
|
|
"""
|
|
Returns:
|
|
(max_3h_sum, first_start_hhmm_of_persistent_exceedance, persistence_hours)
|
|
|
|
Compute rolling 3h sums (hourly precipitation totals).
|
|
Persistence >=2h means: at least `persist_hours` consecutive rolling windows exceed the limit.
|
|
Each shift by 1 hour -> 'persistence_hours' approximates how long intense conditions persist.
|
|
"""
|
|
if end_idx - start_idx < 3:
|
|
return 0.0, "", 0
|
|
|
|
dt_list = [parse_time_to_local(t) for t in times]
|
|
|
|
# rolling sums for each window start i (covers i, i+1, i+2)
|
|
window_starts = list(range(start_idx, end_idx - 2))
|
|
sums = []
|
|
for i in window_starts:
|
|
try:
|
|
s = float(rain[i]) + float(rain[i + 1]) + float(rain[i + 2])
|
|
except Exception:
|
|
s = 0.0
|
|
sums.append(s)
|
|
|
|
# Find persistent exceedance: sums[j] >= limit for >= persist_hours consecutive j
|
|
best_max = 0.0
|
|
best_start = ""
|
|
best_persist = 0
|
|
|
|
consec = 0
|
|
run_start_j = None
|
|
run_max = 0.0
|
|
|
|
for j, s in enumerate(sums):
|
|
if s >= limit_3h:
|
|
if consec == 0:
|
|
run_start_j = j
|
|
run_max = s
|
|
else:
|
|
run_max = max(run_max, s)
|
|
consec += 1
|
|
|
|
if consec >= persist_hours and run_start_j is not None:
|
|
# take first persistent run (meglio uno in più), but keep track of max within it
|
|
if best_persist == 0:
|
|
start_i = window_starts[run_start_j]
|
|
best_start = hhmm(dt_list[start_i])
|
|
best_persist = consec
|
|
best_max = run_max
|
|
else:
|
|
# if same run continues, update
|
|
best_persist = max(best_persist, consec)
|
|
best_max = max(best_max, run_max)
|
|
else:
|
|
consec = 0
|
|
run_start_j = None
|
|
run_max = 0.0
|
|
|
|
return best_max, best_start, best_persist
|
|
|
|
|
|
# =============================================================================
|
|
# MESSAGE BUILDERS
|
|
# =============================================================================
|
|
def wind_message(level: int, peak: float, start_hhmm: str, run_len: int) -> str:
|
|
# run_len is in hours (number of consecutive hourly points)
|
|
if level == 3:
|
|
icon = "🔴"
|
|
title = "TEMPESTA (Burrasca fortissima)"
|
|
thr = WIND_RED
|
|
elif level == 2:
|
|
icon = "🟠"
|
|
title = "VENTO MOLTO FORTE"
|
|
thr = WIND_ORANGE
|
|
else:
|
|
icon = "🟡"
|
|
title = "VENTO FORTE"
|
|
thr = WIND_YELLOW
|
|
|
|
return (
|
|
f"{icon} <b>{title}</b><br/>"
|
|
f"Persistenza: <b>≥ {PERSIST_HOURS} ore</b> sopra soglia ({thr:.0f} km/h).<br/>"
|
|
f"🕒 Inizio stimato: <b>{html.escape(start_hhmm or '—')}</b><br/>"
|
|
f"📈 Picco in finestra: <b>{peak:.0f}</b> km/h (run ~{run_len}h)."
|
|
)
|
|
|
|
|
|
def rain_message(max_3h: float, start_hhmm: str, persist_h: int) -> str:
|
|
return (
|
|
"🌧️ <b>PIOGGIA INTENSA</b><br/>"
|
|
f"Persistenza: <b>≥ {PERSIST_HOURS} ore</b> sopra soglia ({RAIN_3H_LIMIT:.1f} mm/3h).<br/>"
|
|
f"🕒 Inizio stimato: <b>{html.escape(start_hhmm or '—')}</b><br/>"
|
|
f"📈 Max su 3 ore in finestra: <b>{max_3h:.1f} mm</b> (persistenza ~{persist_h}h)."
|
|
)
|
|
|
|
|
|
# =============================================================================
|
|
# MAIN
|
|
# =============================================================================
|
|
def analyze() -> None:
|
|
LOGGER.info("--- Controllo Meteo Severo (Wind/Rain/Ice) ---")
|
|
|
|
data, model_used = get_forecast()
|
|
if not data:
|
|
# No Telegram on errors
|
|
return
|
|
|
|
hourly = (data.get("hourly", {}) or {})
|
|
times = hourly.get("time", []) or []
|
|
gusts = hourly.get("wind_gusts_10m", []) or []
|
|
rain = hourly.get("precipitation", []) or []
|
|
wcode = hourly.get("weather_code", []) or []
|
|
|
|
n = min(len(times), len(gusts), len(rain), len(wcode))
|
|
if n == 0:
|
|
LOGGER.error("Empty hourly series (model=%s).", model_used)
|
|
return
|
|
|
|
times = times[:n]
|
|
gusts = gusts[:n]
|
|
rain = rain[:n]
|
|
wcode = wcode[:n]
|
|
|
|
now = now_local()
|
|
state = load_state()
|
|
was_alarm = bool(state.get("alert_active", False))
|
|
|
|
# Find starting index: first timestep >= now
|
|
start_idx = -1
|
|
for i, t in enumerate(times):
|
|
if parse_time_to_local(t) >= now:
|
|
start_idx = i
|
|
break
|
|
if start_idx == -1:
|
|
LOGGER.error("Could not locate current time index in forecast timeline.")
|
|
return
|
|
|
|
end_idx = min(start_idx + HOURS_AHEAD, n)
|
|
if end_idx <= start_idx:
|
|
LOGGER.error("Invalid horizon window (start=%s end=%s).", start_idx, end_idx)
|
|
return
|
|
|
|
if DEBUG:
|
|
LOGGER.debug("model=%s start_idx=%s end_idx=%s (hours=%s)",
|
|
model_used, start_idx, end_idx, end_idx - start_idx)
|
|
|
|
# --- Freezing detection (no persistence needed) ---
|
|
freezing_detected = False
|
|
freezing_time = ""
|
|
for i in range(start_idx, end_idx):
|
|
try:
|
|
code = int(wcode[i])
|
|
except Exception:
|
|
code = -1
|
|
if code in FREEZING_CODES:
|
|
freezing_detected = True
|
|
if not freezing_time:
|
|
freezing_time = hhmm(parse_time_to_local(times[i]))
|
|
break
|
|
|
|
# --- Wind persistence ---
|
|
wind_level_curr, wind_peak, wind_start, wind_run_len = best_wind_persistent_level(
|
|
gusts=gusts,
|
|
times=times,
|
|
start_idx=start_idx,
|
|
end_idx=end_idx,
|
|
persist_hours=PERSIST_HOURS
|
|
)
|
|
|
|
# --- Rain persistence (3h windows) ---
|
|
rain_max_3h, rain_start, rain_persist = best_rain_persistent_3h(
|
|
rain=rain,
|
|
times=times,
|
|
start_idx=start_idx,
|
|
end_idx=end_idx,
|
|
limit_3h=RAIN_3H_LIMIT,
|
|
persist_hours=PERSIST_HOURS
|
|
)
|
|
|
|
# --- Decide notifications ---
|
|
alerts: List[str] = []
|
|
should_notify = False
|
|
|
|
# 1) Freezing rain (priority)
|
|
if freezing_detected:
|
|
if not bool(state.get("freezing_active", False)):
|
|
alerts.append(
|
|
"🧊 <b>ALLARME GELICIDIO</b><br/>"
|
|
"Prevista <b>pioggia che gela</b> (freezing rain/drizzle).<br/>"
|
|
f"🕒 Inizio stimato: <b>{html.escape(freezing_time or '—')}</b><br/>"
|
|
"<i>Pericolo ghiaccio su strada.</i>"
|
|
)
|
|
should_notify = True
|
|
state["freezing_active"] = True
|
|
else:
|
|
state["freezing_active"] = False
|
|
|
|
# 2) Wind (persistent)
|
|
if wind_level_curr > 0:
|
|
prev_level = int(state.get("wind_level", 0) or 0)
|
|
if (not was_alarm) or (wind_level_curr > prev_level):
|
|
alerts.append(wind_message(wind_level_curr, wind_peak, wind_start, wind_run_len))
|
|
should_notify = True
|
|
state["wind_level"] = wind_level_curr
|
|
state["last_wind_peak"] = float(wind_peak)
|
|
else:
|
|
state["wind_level"] = 0
|
|
state["last_wind_peak"] = 0.0
|
|
|
|
# 3) Rain (persistent)
|
|
if rain_persist >= PERSIST_HOURS and rain_max_3h >= RAIN_3H_LIMIT:
|
|
prev_rain = float(state.get("last_rain_3h", 0.0) or 0.0)
|
|
# "Meglio uno in più": notifica anche al primo superamento persistente,
|
|
# e ri-notifica se peggiora di >= +10mm sul massimo 3h
|
|
if (not was_alarm) or (rain_max_3h >= prev_rain + 10.0):
|
|
alerts.append(rain_message(rain_max_3h, rain_start, rain_persist))
|
|
should_notify = True
|
|
state["last_rain_3h"] = float(rain_max_3h)
|
|
else:
|
|
state["last_rain_3h"] = 0.0
|
|
|
|
is_alarm_now = (
|
|
freezing_detected
|
|
or (wind_level_curr > 0)
|
|
or (rain_persist >= PERSIST_HOURS and rain_max_3h >= RAIN_3H_LIMIT)
|
|
)
|
|
|
|
# --- Send only on alerts (never on errors) ---
|
|
if should_notify and alerts:
|
|
headline = "⚠️ <b>AVVISO METEO SEVERO</b>"
|
|
meta = (
|
|
f"📍 <code>Casa (LAT {LAT:.4f}, LON {LON:.4f})</code><br/>"
|
|
f"🕒 <code>Finestra: prossime {HOURS_AHEAD} ore</code><br/>"
|
|
f"🛰️ <code>Modello: {html.escape(model_used)}</code><br/>"
|
|
f"⏱️ <code>Persistenza minima: {PERSIST_HOURS} ore</code><br/>"
|
|
)
|
|
body = "<br/><br/>".join(alerts)
|
|
footer = "<br/><br/><i>Fonte dati: Open-Meteo</i>"
|
|
msg = f"{headline}<br/>{meta}<br/>{body}{footer}"
|
|
|
|
ok = telegram_send_html(msg)
|
|
if ok:
|
|
LOGGER.info("Alert sent successfully.")
|
|
else:
|
|
LOGGER.warning("Alert NOT sent (token missing or Telegram error).")
|
|
|
|
state["alert_active"] = True
|
|
save_state(state)
|
|
return
|
|
|
|
# Optional: cleared message (transition only)
|
|
if SEND_ALL_CLEAR and was_alarm and (not is_alarm_now):
|
|
msg = (
|
|
"🟢 <b>ALLERTA METEO RIENTRATA</b><br/>"
|
|
"Condizioni rientrate sotto le soglie di guardia.<br/>"
|
|
f"🕒 <code>Finestra: prossime {HOURS_AHEAD} ore</code><br/>"
|
|
f"🛰️ <code>Modello: {html.escape(model_used)}</code><br/>"
|
|
f"⏱️ <code>Persistenza minima: {PERSIST_HOURS} ore</code>"
|
|
)
|
|
ok = telegram_send_html(msg)
|
|
if ok:
|
|
LOGGER.info("All-clear sent successfully.")
|
|
else:
|
|
LOGGER.warning("All-clear NOT sent (token missing or Telegram error).")
|
|
|
|
state = {
|
|
"alert_active": False,
|
|
"wind_level": 0,
|
|
"last_wind_peak": 0.0,
|
|
"last_rain_3h": 0.0,
|
|
"freezing_active": False,
|
|
}
|
|
save_state(state)
|
|
return
|
|
|
|
# No new alert
|
|
state["alert_active"] = bool(is_alarm_now)
|
|
save_state(state)
|
|
LOGGER.info(
|
|
"No new alert. model=%s wind_level=%s rain3h=%.1fmm(persist=%sh) ice=%s",
|
|
model_used, wind_level_curr, rain_max_3h, rain_persist, freezing_detected
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
analyze()
|