"""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)