115 lines
4.4 KiB
Python
115 lines
4.4 KiB
Python
"""Buienradar's documented coordinate-based two-hour rain forecast feed."""
|
|
|
|
import hashlib
|
|
import re
|
|
from datetime import datetime, time as clock_time, timedelta, timezone
|
|
from urllib.parse import urlencode
|
|
from urllib.request import Request, urlopen
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from django.core.cache import caches
|
|
|
|
from .weather import coordinates
|
|
|
|
ENDPOINT = "https://gps.buienradar.nl/getrr.php"
|
|
FRESH_SECONDS = 300
|
|
STALE_SECONDS = 900
|
|
AMSTERDAM = ZoneInfo("Europe/Amsterdam")
|
|
LINE = re.compile(r"^(\d{3})\|([01]\d|2[0-3]):([0-5]\d)$")
|
|
|
|
|
|
class RainUnavailable(Exception):
|
|
pass
|
|
|
|
|
|
def rain_label(intensity):
|
|
# UI categories; Buienradar supplies the raw rain code, not these labels.
|
|
if intensity < 0.1:
|
|
return "None"
|
|
if intensity < 2.5:
|
|
return "Light"
|
|
if intensity < 10:
|
|
return "Moderate"
|
|
return "Heavy"
|
|
|
|
|
|
def parse_forecast(text, now=None):
|
|
now = now or datetime.now(AMSTERDAM)
|
|
if now.tzinfo is None:
|
|
raise ValueError("Timezone-aware now required")
|
|
rows = [line.strip() for line in text.splitlines() if line.strip()]
|
|
if not 1 <= len(rows) <= 36:
|
|
raise RainUnavailable("Rain forecast format is unavailable")
|
|
points = []
|
|
previous = None
|
|
base_date = now.date()
|
|
day_offset = 0
|
|
for row in rows:
|
|
match = LINE.fullmatch(row)
|
|
if not match:
|
|
raise RainUnavailable("Rain forecast format is unavailable")
|
|
code, hour, minute = map(int, match.groups())
|
|
if code > 255:
|
|
raise RainUnavailable("Rain forecast format is unavailable")
|
|
time = datetime.combine(base_date + timedelta(days=day_offset), clock_time(hour, minute), AMSTERDAM)
|
|
if previous is None:
|
|
if time - now > timedelta(hours=12):
|
|
time -= timedelta(days=1)
|
|
day_offset -= 1
|
|
elif now - time > timedelta(hours=12):
|
|
time += timedelta(days=1)
|
|
day_offset += 1
|
|
elif time <= previous:
|
|
day_offset += 1
|
|
time += timedelta(days=1)
|
|
if previous is not None and not timedelta(minutes=0) < time - previous <= timedelta(minutes=10):
|
|
raise RainUnavailable("Rain forecast timing is unavailable")
|
|
previous = time
|
|
intensity = 0 if code == 0 else 10 ** ((code - 109) / 32)
|
|
# The upper end of the 0-255 scale is saturated; an exact rate would imply false precision.
|
|
points.append({"time": time.isoformat(), "mm_per_hour": round(intensity, 2) if intensity < 100 else None, "label": rain_label(intensity)})
|
|
return points
|
|
|
|
|
|
def request_rain(lat, lon):
|
|
url = f"{ENDPOINT}?{urlencode({'lat': lat, 'lon': lon})}"
|
|
request = Request(url, headers={"User-Agent": "CommonGroundDashboard/1.0"})
|
|
with urlopen(request, timeout=8) as response:
|
|
if response.status != 200:
|
|
raise RainUnavailable("Rain service is temporarily unavailable")
|
|
body = response.read(10000)
|
|
try:
|
|
points = parse_forecast(body.decode("ascii"))
|
|
except UnicodeDecodeError as exc:
|
|
raise RainUnavailable("Rain forecast format is unavailable") from exc
|
|
return {"points": points, "fetched_at": datetime.now(timezone.utc).isoformat()}
|
|
|
|
|
|
def get_rain(latitude, longitude):
|
|
lat, lon = coordinates(latitude, longitude)
|
|
# The documented feed covers the Netherlands; avoid meaningless global requests.
|
|
if not (50.5 <= lat <= 53.7 and 3.0 <= lon <= 7.3):
|
|
raise ValueError("Buienradar's local rain forecast is available for locations in the Netherlands")
|
|
key = hashlib.sha256(f"buienradar:v1:{lat:.2f}:{lon:.2f}".encode()).hexdigest()
|
|
cache = caches["weather"]
|
|
fresh = cache.get(f"fresh:{key}")
|
|
if fresh is not None:
|
|
return {**fresh, "stale": False}
|
|
stale = cache.get(f"stale:{key}")
|
|
lock = f"lock:{key}"
|
|
if not cache.add(lock, True, timeout=20):
|
|
if stale is not None:
|
|
return {**stale, "stale": True}
|
|
raise RainUnavailable("Rain forecast is being refreshed. Try again shortly")
|
|
try:
|
|
payload = request_rain(lat, lon)
|
|
cache.set(f"fresh:{key}", payload, timeout=FRESH_SECONDS)
|
|
cache.set(f"stale:{key}", payload, timeout=STALE_SECONDS)
|
|
return {**payload, "stale": False}
|
|
except (OSError, RainUnavailable) as exc:
|
|
if stale is not None:
|
|
return {**stale, "stale": True}
|
|
raise RainUnavailable("Rain service is temporarily unavailable") from exc
|
|
finally:
|
|
cache.delete(lock)
|