556 lines
20 KiB
Python
556 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Generate a Markdown weather report for one KalliHome archive day.
|
|
|
|
The script queries Grafana's InfluxDB datasource through /api/ds/query. It does
|
|
not store credentials; provide a Grafana service account token through
|
|
GRAFANA_SERVICE_ACCOUNT_TOKEN or GRAFANA_TOKEN_FILE.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import math
|
|
import os
|
|
import sys
|
|
import urllib.error
|
|
import urllib.request
|
|
from datetime import date, datetime, time, timedelta, timezone, tzinfo
|
|
from typing import Any
|
|
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
|
|
|
|
|
|
DEFAULT_GRAFANA_URL = "https://monitoring.kaleschke.info"
|
|
DEFAULT_TOKEN_FILE = "/mnt/user/appdata/secrets/monitoring_grafana_weather_report_token.txt"
|
|
DATASOURCE_UID = "ha-weather-influx"
|
|
DATASOURCE_TYPE = "influxdb"
|
|
|
|
TEMP_TABLE = "\u00b0C"
|
|
SOLAR_TABLE = "W/m\u00b2"
|
|
|
|
|
|
class WeatherReportError(RuntimeError):
|
|
pass
|
|
|
|
|
|
def last_sunday(year: int, month: int) -> date:
|
|
current = date(year, month + 1, 1) - timedelta(days=1) if month < 12 else date(year, 12, 31)
|
|
return current - timedelta(days=(current.weekday() + 1) % 7)
|
|
|
|
|
|
class EuropeBerlinFallback(tzinfo):
|
|
"""Small Europe/Berlin fallback for systems without IANA tzdata."""
|
|
|
|
def _dst_bounds_utc(self, year: int) -> tuple[datetime, datetime]:
|
|
start = datetime.combine(last_sunday(year, 3), time(1, 0), tzinfo=timezone.utc)
|
|
end = datetime.combine(last_sunday(year, 10), time(1, 0), tzinfo=timezone.utc)
|
|
return start, end
|
|
|
|
def _is_dst_utc(self, dt: datetime) -> bool:
|
|
utc_dt = dt.replace(tzinfo=timezone.utc) if dt.tzinfo is self else dt.astimezone(timezone.utc)
|
|
start, end = self._dst_bounds_utc(utc_dt.year)
|
|
return start <= utc_dt < end
|
|
|
|
def _is_dst_local(self, dt: datetime) -> bool:
|
|
naive = dt.replace(tzinfo=None)
|
|
start = datetime.combine(last_sunday(naive.year, 3), time(2, 0))
|
|
end = datetime.combine(last_sunday(naive.year, 10), time(3, 0))
|
|
return start <= naive < end
|
|
|
|
def utcoffset(self, dt: datetime | None) -> timedelta:
|
|
if dt is not None and self._is_dst_local(dt):
|
|
return timedelta(hours=2)
|
|
return timedelta(hours=1)
|
|
|
|
def dst(self, dt: datetime | None) -> timedelta:
|
|
if dt is not None and self._is_dst_local(dt):
|
|
return timedelta(hours=1)
|
|
return timedelta(0)
|
|
|
|
def tzname(self, dt: datetime | None) -> str:
|
|
return "CEST" if dt is not None and self._is_dst_local(dt) else "CET"
|
|
|
|
def fromutc(self, dt: datetime) -> datetime:
|
|
offset = timedelta(hours=2) if self._is_dst_utc(dt) else timedelta(hours=1)
|
|
return (dt.replace(tzinfo=timezone.utc) + offset).replace(tzinfo=self)
|
|
|
|
|
|
def load_timezone(tz_name: str) -> tzinfo:
|
|
try:
|
|
return ZoneInfo(tz_name)
|
|
except ZoneInfoNotFoundError:
|
|
if tz_name == "Europe/Berlin":
|
|
return EuropeBerlinFallback()
|
|
raise
|
|
|
|
|
|
def parse_args() -> argparse.Namespace:
|
|
parser = argparse.ArgumentParser(description="Generate a KalliHome weather day report.")
|
|
parser.add_argument(
|
|
"--date",
|
|
default=os.environ.get("WEATHER_REPORT_DATE"),
|
|
help="Local report date as YYYY-MM-DD. Defaults to yesterday in --timezone.",
|
|
)
|
|
parser.add_argument(
|
|
"--timezone",
|
|
default=os.environ.get("WEATHER_REPORT_TZ", "Europe/Berlin"),
|
|
help="IANA timezone for the local day boundary. Default: Europe/Berlin.",
|
|
)
|
|
parser.add_argument(
|
|
"--grafana-url",
|
|
default=os.environ.get("GRAFANA_URL", DEFAULT_GRAFANA_URL),
|
|
help=f"Grafana base URL. Default: {DEFAULT_GRAFANA_URL}",
|
|
)
|
|
parser.add_argument(
|
|
"--token-file",
|
|
default=os.environ.get("GRAFANA_TOKEN_FILE", DEFAULT_TOKEN_FILE),
|
|
help=f"Grafana service account token file. Default: {DEFAULT_TOKEN_FILE}",
|
|
)
|
|
parser.add_argument(
|
|
"--heading-level",
|
|
type=int,
|
|
default=int(os.environ.get("WEATHER_REPORT_HEADING_LEVEL", "1")),
|
|
choices=range(1, 5),
|
|
help="Markdown heading level for the title. Default: 1.",
|
|
)
|
|
parser.add_argument(
|
|
"--json",
|
|
action="store_true",
|
|
help="Print raw summarized values as JSON instead of Markdown.",
|
|
)
|
|
return parser.parse_args()
|
|
|
|
|
|
def read_token(token_file: str) -> str:
|
|
token = os.environ.get("GRAFANA_SERVICE_ACCOUNT_TOKEN", "").strip()
|
|
if token:
|
|
return token
|
|
try:
|
|
with open(token_file, "r", encoding="utf-8-sig") as handle:
|
|
token = handle.read().strip()
|
|
except FileNotFoundError as exc:
|
|
raise WeatherReportError(
|
|
f"Grafana token missing. Set GRAFANA_SERVICE_ACCOUNT_TOKEN or create {token_file}."
|
|
) from exc
|
|
if not token:
|
|
raise WeatherReportError(f"Grafana token file is empty: {token_file}")
|
|
return token
|
|
|
|
|
|
def day_bounds(report_date: str | None, tz_name: str) -> tuple[date, datetime, datetime]:
|
|
tz = load_timezone(tz_name)
|
|
if report_date:
|
|
local_date = date.fromisoformat(report_date)
|
|
else:
|
|
local_date = datetime.now(tz).date() - timedelta(days=1)
|
|
start_local = datetime.combine(local_date, time.min, tzinfo=tz)
|
|
end_local = start_local + timedelta(days=1)
|
|
return (
|
|
local_date,
|
|
start_local.astimezone(timezone.utc),
|
|
end_local.astimezone(timezone.utc),
|
|
)
|
|
|
|
|
|
def sql_timestamp(dt: datetime) -> str:
|
|
return dt.astimezone(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
|
|
|
|
|
|
def grafana_query(
|
|
grafana_url: str,
|
|
token: str,
|
|
sql: str,
|
|
start_utc: datetime,
|
|
end_utc: datetime,
|
|
) -> list[dict[str, Any]]:
|
|
url = grafana_url.rstrip("/") + "/api/ds/query"
|
|
payload = {
|
|
"queries": [
|
|
{
|
|
"refId": "A",
|
|
"datasource": {"uid": DATASOURCE_UID, "type": DATASOURCE_TYPE},
|
|
"rawQuery": True,
|
|
"rawSql": sql,
|
|
"format": "table",
|
|
}
|
|
],
|
|
"from": sql_timestamp(start_utc),
|
|
"to": sql_timestamp(end_utc),
|
|
}
|
|
body = json.dumps(payload).encode("utf-8")
|
|
request = urllib.request.Request(
|
|
url,
|
|
data=body,
|
|
headers={
|
|
"Authorization": f"Bearer {token}",
|
|
"Content-Type": "application/json",
|
|
},
|
|
method="POST",
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(request, timeout=30) as response:
|
|
data = json.loads(response.read().decode("utf-8"))
|
|
except urllib.error.HTTPError as exc:
|
|
detail = exc.read().decode("utf-8", errors="replace")
|
|
raise WeatherReportError(f"Grafana query failed with HTTP {exc.code}: {detail}") from exc
|
|
except urllib.error.URLError as exc:
|
|
raise WeatherReportError(f"Grafana is not reachable: {exc}") from exc
|
|
|
|
result = data.get("results", {}).get("A", {})
|
|
if result.get("error"):
|
|
raise WeatherReportError(f"Grafana datasource error: {result['error']}")
|
|
frames = result.get("frames") or []
|
|
if not frames:
|
|
return []
|
|
frame = frames[0]
|
|
fields = [field["name"] for field in frame.get("schema", {}).get("fields", [])]
|
|
values = frame.get("data", {}).get("values", [])
|
|
if not fields or not values:
|
|
return []
|
|
rows: list[dict[str, Any]] = []
|
|
for idx in range(len(values[0])):
|
|
rows.append({field: values[pos][idx] for pos, field in enumerate(fields)})
|
|
return rows
|
|
|
|
|
|
def one(rows: list[dict[str, Any]]) -> dict[str, Any]:
|
|
return rows[0] if rows else {}
|
|
|
|
|
|
def by_entity(rows: list[dict[str, Any]], entity_id: str) -> dict[str, Any]:
|
|
for row in rows:
|
|
if row.get("entity_id") == entity_id:
|
|
return row
|
|
return {}
|
|
|
|
|
|
def as_float(value: Any) -> float | None:
|
|
if value is None:
|
|
return None
|
|
try:
|
|
number = float(value)
|
|
except (TypeError, ValueError):
|
|
return None
|
|
if math.isnan(number):
|
|
return None
|
|
return number
|
|
|
|
|
|
def fmt(value: Any, digits: int = 1, missing: str = "n/a") -> str:
|
|
number = as_float(value)
|
|
if number is None:
|
|
return missing
|
|
return f"{number:.{digits}f}".replace(".", ",")
|
|
|
|
|
|
def fmt_int(value: Any, missing: str = "n/a") -> str:
|
|
number = as_float(value)
|
|
if number is None:
|
|
return missing
|
|
return f"{round(number):d}"
|
|
|
|
|
|
def fmt_signed(value: Any, digits: int = 1) -> str:
|
|
number = as_float(value)
|
|
if number is None:
|
|
return "n/a"
|
|
sign = "+" if number > 0 else ""
|
|
return f"{sign}{number:.{digits}f}".replace(".", ",")
|
|
|
|
|
|
def local_hhmm(value: Any, tz_name: str) -> str:
|
|
if value in (None, ""):
|
|
return "n/a"
|
|
tz = load_timezone(tz_name)
|
|
if isinstance(value, (int, float)):
|
|
return datetime.fromtimestamp(float(value) / 1000, timezone.utc).astimezone(tz).strftime("%H:%M")
|
|
if isinstance(value, str):
|
|
try:
|
|
# Grafana may return ISO timestamps or millisecond timestamps encoded as strings.
|
|
if value.isdigit():
|
|
return datetime.fromtimestamp(float(value) / 1000, timezone.utc).astimezone(tz).strftime("%H:%M")
|
|
normalized = value.replace("Z", "+00:00")
|
|
return datetime.fromisoformat(normalized).astimezone(tz).strftime("%H:%M")
|
|
except ValueError:
|
|
return value
|
|
return str(value)
|
|
|
|
|
|
def summarize(grafana_url: str, token: str, report_date: date, start_utc: datetime, end_utc: datetime) -> dict[str, Any]:
|
|
start = sql_timestamp(start_utc)
|
|
end = sql_timestamp(end_utc)
|
|
where = f"time >= timestamp '{start}' AND time < timestamp '{end}'"
|
|
|
|
temp = grafana_query(
|
|
grafana_url,
|
|
token,
|
|
(
|
|
f'SELECT entity_id, count(value) AS samples, min(value) AS min_value, '
|
|
f'max(value) AS max_value, avg(value) AS avg_value FROM "{TEMP_TABLE}" '
|
|
"WHERE entity_id IN ('gw3000a_outdoor_temperature',"
|
|
"'gw3000a_feels_like_temperature','gw3000a_dewpoint') "
|
|
f"AND {where} GROUP BY entity_id ORDER BY entity_id"
|
|
),
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
humidity = grafana_query(
|
|
grafana_url,
|
|
token,
|
|
(
|
|
'SELECT entity_id, count(value) AS samples, min(value) AS min_value, '
|
|
'max(value) AS max_value, avg(value) AS avg_value FROM "%" '
|
|
"WHERE entity_id IN ('gw3000a_humidity','gw3000a_indoor_humidity') "
|
|
f"AND {where} GROUP BY entity_id ORDER BY entity_id"
|
|
),
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
wind = grafana_query(
|
|
grafana_url,
|
|
token,
|
|
(
|
|
'SELECT entity_id, count(value) AS samples, min(value) AS min_value, '
|
|
'max(value) AS max_value, avg(value) AS avg_value FROM "km/h" '
|
|
"WHERE entity_id IN ('gw3000a_wind_speed','gw3000a_wind_gust') "
|
|
f"AND {where} GROUP BY entity_id ORDER BY entity_id"
|
|
),
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
|
|
return {
|
|
"date": report_date.isoformat(),
|
|
"start_utc": start,
|
|
"end_utc": end,
|
|
"outdoor_temperature": by_entity(temp, "gw3000a_outdoor_temperature"),
|
|
"feels_like": by_entity(temp, "gw3000a_feels_like_temperature"),
|
|
"dewpoint": by_entity(temp, "gw3000a_dewpoint"),
|
|
"humidity": by_entity(humidity, "gw3000a_humidity"),
|
|
"wind_speed": by_entity(wind, "gw3000a_wind_speed"),
|
|
"wind_gust": by_entity(wind, "gw3000a_wind_gust"),
|
|
"rain": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT count(value) AS samples, max(value) AS rain_mm FROM "mm" '
|
|
f"WHERE entity_id = 'gw3000a_daily_rain' AND {where}",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"solar": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT count(value) AS samples, max(value) AS max_value, avg(value) AS avg_value '
|
|
f'FROM "{SOLAR_TABLE}" WHERE entity_id = \'gw3000a_solar_radiation\' AND {where}',
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"uv": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT count(value) AS samples, max(value) AS max_value, avg(value) AS avg_value '
|
|
f'FROM "UV index" WHERE entity_id = \'gw3000a_uv_index\' AND {where}',
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"pressure": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT count(value) AS samples, min(value) AS min_value, max(value) AS max_value, '
|
|
f'avg(value) AS avg_value FROM "hPa" WHERE entity_id = \'gw3000a_relative_pressure\' AND {where}',
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"pressure_start": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT time, value FROM "hPa" WHERE entity_id = \'gw3000a_relative_pressure\' '
|
|
f"AND {where} ORDER BY time ASC LIMIT 1",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"pressure_end": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT time, value FROM "hPa" WHERE entity_id = \'gw3000a_relative_pressure\' '
|
|
f"AND {where} ORDER BY time DESC LIMIT 1",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"temperature_min_time": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT time, value FROM "{TEMP_TABLE}" WHERE entity_id = \'gw3000a_outdoor_temperature\' '
|
|
f"AND {where} ORDER BY value ASC LIMIT 1",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"temperature_max_time": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT time, value FROM "{TEMP_TABLE}" WHERE entity_id = \'gw3000a_outdoor_temperature\' '
|
|
f"AND {where} ORDER BY value DESC LIMIT 1",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"gust_max_time": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT time, value FROM "km/h" WHERE entity_id = \'gw3000a_wind_gust\' '
|
|
f"AND {where} ORDER BY value DESC LIMIT 1",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"solar_max_time": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT time, value FROM "{SOLAR_TABLE}" WHERE entity_id = \'gw3000a_solar_radiation\' '
|
|
f"AND {where} ORDER BY value DESC LIMIT 1",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
"uv_max_time": one(
|
|
grafana_query(
|
|
grafana_url,
|
|
token,
|
|
f'SELECT time, value FROM "UV index" WHERE entity_id = \'gw3000a_uv_index\' '
|
|
f"AND {where} ORDER BY value DESC LIMIT 1",
|
|
start_utc,
|
|
end_utc,
|
|
)
|
|
),
|
|
}
|
|
|
|
|
|
def render_markdown(summary: dict[str, Any], tz_name: str, heading_level: int) -> str:
|
|
out_temp = summary["outdoor_temperature"]
|
|
feels = summary["feels_like"]
|
|
dew = summary["dewpoint"]
|
|
humidity = summary["humidity"]
|
|
wind_speed = summary["wind_speed"]
|
|
wind_gust = summary["wind_gust"]
|
|
rain = summary["rain"]
|
|
solar = summary["solar"]
|
|
uv = summary["uv"]
|
|
pressure = summary["pressure"]
|
|
|
|
pressure_start = as_float(summary["pressure_start"].get("value"))
|
|
pressure_end = as_float(summary["pressure_end"].get("value"))
|
|
pressure_trend = None if pressure_start is None or pressure_end is None else pressure_end - pressure_start
|
|
|
|
solar_max = as_float(solar.get("max_value"))
|
|
uv_max = as_float(uv.get("max_value"))
|
|
temp_max = as_float(out_temp.get("max_value"))
|
|
if solar_max is not None and uv_max is not None and solar_max >= 700 and uv_max >= 6:
|
|
narrative = (
|
|
"Der Tag war warm, hell und ueberwiegend sonnig; die hohe Solarstrahlung "
|
|
f"und der UV-Index von {fmt(uv_max)} passen klar zu einem schoenen Sommertag."
|
|
)
|
|
elif temp_max is not None and temp_max >= 25:
|
|
narrative = "Der Tag war warm; die Messwerte sprechen fuer sommerliches Wetter."
|
|
else:
|
|
narrative = "Der Tag war wettertechnisch unauffaellig; die folgenden Messwerte fassen ihn zusammen."
|
|
|
|
rain_samples = int(as_float(rain.get("samples")) or 0)
|
|
if rain_samples > 0:
|
|
rain_line = f"- Regen: {fmt(rain.get('rain_mm'))} mm Tagesmenge laut daily_rain."
|
|
else:
|
|
rain_line = (
|
|
f"- Regen: fuer {summary['date']} nicht belastbar auswertbar, "
|
|
"weil `gw3000a_daily_rain` an dem Tag keine Samples hatte."
|
|
)
|
|
|
|
heading = "#" * heading_level
|
|
lines = [
|
|
f"{heading} Wetterbericht KalliHome - {summary['date']}",
|
|
"",
|
|
f"Zeitraum: {summary['date']} 00:00 bis 24:00 Europe/Berlin.",
|
|
"",
|
|
narrative,
|
|
"",
|
|
(
|
|
f"- Temperatur aussen: {fmt(out_temp.get('min_value'))} bis {fmt(out_temp.get('max_value'))} °C, "
|
|
f"Mittel {fmt(out_temp.get('avg_value'))} °C. "
|
|
f"Minimum um {local_hhmm(summary['temperature_min_time'].get('time'), tz_name)}, "
|
|
f"Maximum um {local_hhmm(summary['temperature_max_time'].get('time'), tz_name)}."
|
|
),
|
|
(
|
|
f"- Gefuehlt: Maximum {fmt(feels.get('max_value'))} °C, "
|
|
f"Mittel {fmt(feels.get('avg_value'))} °C. "
|
|
f"Taupunkt im Mittel {fmt(dew.get('avg_value'))} °C."
|
|
),
|
|
(
|
|
f"- Luftfeuchte aussen: {fmt_int(humidity.get('min_value'))} bis "
|
|
f"{fmt_int(humidity.get('max_value'))} %, Mittel {fmt_int(humidity.get('avg_value'))} %."
|
|
),
|
|
(
|
|
f"- Wind: Mittel {fmt(wind_speed.get('avg_value'))} km/h, "
|
|
f"Maximum Wind {fmt(wind_speed.get('max_value'))} km/h; "
|
|
f"staerkste Boe {fmt(wind_gust.get('max_value'))} km/h um "
|
|
f"{local_hhmm(summary['gust_max_time'].get('time'), tz_name)}."
|
|
),
|
|
rain_line,
|
|
(
|
|
f"- Solarstrahlung: Maximum {fmt_int(solar.get('max_value'))} W/m² um "
|
|
f"{local_hhmm(summary['solar_max_time'].get('time'), tz_name)}, "
|
|
f"Mittel {fmt_int(solar.get('avg_value'))} W/m²."
|
|
),
|
|
f"- UV-Index: Maximum {fmt(uv.get('max_value'))} um {local_hhmm(summary['uv_max_time'].get('time'), tz_name)}.",
|
|
(
|
|
f"- Luftdruck: {fmt_int(pressure.get('min_value'))} bis {fmt_int(pressure.get('max_value'))} hPa, "
|
|
f"Mittel {fmt_int(pressure.get('avg_value'))} hPa; "
|
|
f"Tendenz {fmt_signed(pressure_trend)} hPa ueber den Tag."
|
|
),
|
|
"",
|
|
"Datenabdeckung/Samples:",
|
|
(
|
|
f"- Temperatur aussen: {out_temp.get('samples', 0)}, "
|
|
f"Luftfeuchte aussen: {humidity.get('samples', 0)}, "
|
|
f"Wind: {wind_speed.get('samples', 0)}, Boeen: {wind_gust.get('samples', 0)}, "
|
|
f"Regen: {rain.get('samples', 0)}, Solar: {solar.get('samples', 0)}, "
|
|
f"UV: {uv.get('samples', 0)}, Luftdruck: {pressure.get('samples', 0)}"
|
|
),
|
|
]
|
|
return "\n".join(lines)
|
|
|
|
|
|
def main() -> int:
|
|
args = parse_args()
|
|
try:
|
|
token = read_token(args.token_file)
|
|
report_date, start_utc, end_utc = day_bounds(args.date, args.timezone)
|
|
summary = summarize(args.grafana_url, token, report_date, start_utc, end_utc)
|
|
if args.json:
|
|
print(json.dumps(summary, ensure_ascii=False, indent=2))
|
|
else:
|
|
print(render_markdown(summary, args.timezone, args.heading_level))
|
|
except Exception as exc:
|
|
print(f"weather-day-report: {exc}", file=sys.stderr)
|
|
return 1
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|