| |
| """Pure parsing for the EU price job: an Energy-Charts /price response in, the hourly local-time days that |
| /api/nordic serves out. No network, no files, stdlib only. |
| |
| The source. https://api.energy-charts.info/price?bzn=<zone>&start=<date>&end=<date> (Fraunhofer ISE) returns the |
| day-ahead price of a bidding zone as JSON: |
| {"license_info": "CC BY 4.0 (creativecommons.org/licenses/by/4.0) from Bundesnetzagentur | SMARD.de", |
| "unix_seconds": [1792879200, ...], "price": [9.67, ...], "unit": "EUR / MWh", "deprecated": false} |
| * Every timestamp is the START of the period its price covers (the API's own rule), in unix seconds. |
| * The step is 900 s (15 minutes) from the 15-minute market time unit of October 2025, 3600 s before; the step of a |
| value is the distance to the next timestamp, so a series that changes resolution is read correctly. |
| * A price can be null: that slot has no price and is skipped (an hour made only of null slots has none). |
| * A day that is not published yet is simply not in the arrays (tomorrow before the auction results, about 13:00 CET); |
| the API answers 404 when there is nothing at all in the range. |
| * The data of DE-LU, FR, PL and IT-North is licensed CC BY 4.0, attributed to "Bundesnetzagentur | SMARD.de"; this |
| module changes it (hourly means of the 15-minute prices), which the site says wherever it shows them. |
| |
| Local days. The site shows a zone's prices by the zone's own wall clock (Europe/Berlin, Paris, Warsaw, Rome), hour |
| 0..23, like the Nordic feed. Every slot is cut into 15-minute cells and each cell is put in the local (date, hour) it |
| starts in; an hour's price is the mean of its cells. On the day the clocks go back, local hour 2 happens twice and its |
| price is the mean of both (as the Nordic dataset does); on the day they go forward, hour 2 does not exist and its price |
| is null. A day is kept when at least MIN_HOURS of its hours have a price. |
| """ |
| import json |
| from datetime import datetime, timedelta, timezone |
| from zoneinfo import ZoneInfo |
|
|
| CELL = 15 |
| MIN_HOURS = 12 |
| UTC = timezone.utc |
|
|
|
|
| def parse_price(body): |
| """[(start_utc, minutes, price EUR/MWh)] for every priced slot, sorted by start. |
| |
| `body` is the response text (or the parsed dict). A response with no series (HTTP 404 in practice, or null |
| arrays) parses to []. Raises ValueError for something that is not a price document.""" |
| if isinstance(body, (str, bytes)): |
| try: |
| body = json.loads(body) |
| except ValueError as e: |
| raise ValueError(f"not JSON: {e}") |
| if not isinstance(body, dict) or "unix_seconds" not in body or "price" not in body: |
| raise ValueError("not an Energy-Charts price document") |
| u, p = body["unix_seconds"], body["price"] |
| if not u or not p: |
| return [] |
| if len(u) != len(p): |
| raise ValueError(f"unix_seconds ({len(u)}) and price ({len(p)}) differ in length") |
| unit = str(body.get("unit", "EUR / MWh")).replace(" ", "").upper() |
| if unit != "EUR/MWH": |
| raise ValueError(f"unexpected unit {body.get('unit')!r}") |
| steps = [b - a for a, b in zip(u, u[1:])] |
| default = min([s for s in steps if s > 0] or [3600]) |
| out = [] |
| for i, (t, price) in enumerate(zip(u, p)): |
| if price is None: |
| continue |
| step = steps[i] if i < len(steps) else (steps[-1] if steps else default) |
| if step <= 0 or step % (CELL * 60): |
| raise ValueError(f"odd step of {step} s at {t}") |
| out.append((datetime.fromtimestamp(t, UTC), step // 60, float(price))) |
| return sorted(out) |
|
|
|
|
| def license_info(body): |
| """The licence line the API sends with the data, or ''.""" |
| if isinstance(body, (str, bytes)): |
| try: |
| body = json.loads(body) |
| except ValueError: |
| return "" |
| return str(body.get("license_info", "")) if isinstance(body, dict) else "" |
|
|
|
|
| def hourly_days(slots, tzname): |
| """{'YYYY-MM-DD': {hour: mean price}} by the wall clock of `tzname`.""" |
| tz = ZoneInfo(tzname) |
| acc = {} |
| for start, minutes, price in slots: |
| for i in range(minutes // CELL): |
| loc = (start + timedelta(minutes=CELL * i)).astimezone(tz) |
| acc.setdefault(loc.date().isoformat(), {}).setdefault(loc.hour, []).append(price) |
| return {d: {h: sum(v) / len(v) for h, v in hours.items()} for d, hours in acc.items()} |
|
|
|
|
| def build_days(slots, tzname, dates, min_hours=MIN_HOURS): |
| """The feed's days[] for the local `dates` (ISO strings) that have enough prices, in date order: |
| [{date, type:'actual', prices:[{hour, eur_mwh}] * 24}], eur_mwh null for an hour without a price.""" |
| hd = hourly_days(slots, tzname) |
| out = [] |
| for d in sorted(dates): |
| hours = hd.get(d, {}) |
| if len(hours) < min_hours: |
| continue |
| out.append({"date": d, "type": "actual", |
| "prices": [{"hour": h, "eur_mwh": (round(hours[h], 2) if h in hours else None)} |
| for h in range(24)]}) |
| return out |
|
|
|
|
| def local_dates(now_utc, tzname): |
| """[yesterday, today, tomorrow] as ISO dates of the zone's own calendar.""" |
| today = now_utc.astimezone(ZoneInfo(tzname)).date() |
| return [(today + timedelta(days=i)).isoformat() for i in (-1, 0, 1)] |
|
|
|
|
| def build_payload(zone, body, tzname, dates, generated): |
| """The KV value for one zone, shaped like nordic-forecast-<zone> (and so like /api/nordic, which adds |
| zoneInfo when it serves it): every day is 'actual', there is no model, so trainedThrough is null. |
| `generated` is a date, not a timestamp, so a rerun with unchanged data is byte-identical.""" |
| days = build_days(parse_price(body), tzname, dates) |
| return {"zone": zone, "generated": generated, "trainedThrough": None, |
| "unit": "EUR/MWh", "days": days} |
|
|
|
|
| def canonical(value): |
| """The one serialisation that is written to KV and compared against what is stored.""" |
| return json.dumps(value, separators=(",", ":"), ensure_ascii=False) |
|
|
|
|
| def body_hash(value): |
| """FNV-1a of the canonical body, like bodyHash() in functions/api/[[catchall]].js (the same idea: an |
| unchanged body must not consume one of the free plan's 1,000 KV writes a day).""" |
| s = canonical(value).encode("utf-8") |
| h = 0x811c9dc5 |
| for b in s: |
| h = ((h ^ b) * 0x01000193) & 0xFFFFFFFF |
| return f"{h:x}:{len(s)}" |
|
|
