| """The curated record (data/gnlw): every Arriva train between Leeuwarden and Groningen, January-June 2025, with its |
| schedule, delays and cancellations; the derived rolling-stock links; the real disruptions; the minimum running times. |
| |
| `day_runs(day)` turns one service day into model runs: the route through every point (junctions included), the |
| scheduled stops, the timetable's passing minutes at the points in between (interpolated by distance) and the |
| minimum running time of every section (the calibrated stop-to-stop minimum, split by distance). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import csv |
| import gzip |
| import json |
| from dataclasses import dataclass, field |
| from functools import lru_cache |
| from pathlib import Path |
|
|
| from .model import Run |
| from .network import DATA, Network, load_network |
|
|
| LINE_DIR = DATA / "gnlw" |
| KIND = {"Stoptrein": "stop", "Sneltrein": "fast"} |
|
|
|
|
| @dataclass |
| class Stop: |
| code: str |
| sa: int | None |
| sd: int | None |
| ad: int | None |
| dd: int | None |
| arr_cxl: bool |
| dep_cxl: bool |
|
|
| @property |
| def aa(self) -> int | None: |
| return None if self.sa is None or self.ad is None else self.sa + self.ad |
|
|
| @property |
| def adep(self) -> int | None: |
| return None if self.sd is None or self.dd is None else self.sd + self.dd |
|
|
|
|
| @dataclass |
| class Service: |
| train: str |
| type: str |
| stops: list[Stop] |
| full_cxl: bool |
| part_cxl: bool |
|
|
| @property |
| def kind(self) -> str: |
| return KIND.get(self.type, "stop") |
|
|
|
|
| @dataclass |
| class Day: |
| date: str |
| services: dict[str, Service] |
| links: dict[str, str] |
| runs: dict[str, Run] = field(default_factory=dict) |
| chains: list[list[str]] = field(default_factory=list) |
|
|
|
|
| def _int(x: str) -> int | None: |
| return int(x) if x not in ("", None) else None |
|
|
|
|
| @lru_cache(maxsize=1) |
| def _all_services() -> dict[str, dict[str, Service]]: |
| by_day: dict[str, dict[str, Service]] = {} |
| rows: dict[tuple, list[dict]] = {} |
| with gzip.open(LINE_DIR / "services_2025h1.csv.gz", "rt", encoding="utf-8") as f: |
| for r in csv.DictReader(f): |
| rows.setdefault((r["date"], r["svc"]), []).append(r) |
| for (day, _), rs in rows.items(): |
| rs.sort(key=lambda r: int(r["seq"])) |
| s = Service(rs[0]["train"], rs[0]["type"], |
| [Stop(r["code"], _int(r["sched_arr"]), _int(r["sched_dep"]), _int(r["arr_delay"]), |
| _int(r["dep_delay"]), r["arr_cxl"] == "1", r["dep_cxl"] == "1") for r in rs], |
| rs[0]["full_cxl"] == "1", rs[0]["part_cxl"] == "1") |
| by_day.setdefault(day, {}) |
| if s.train in by_day[day]: |
| s.train = f"{s.train}b" |
| by_day[day][s.train] = s |
| return by_day |
|
|
|
|
| @lru_cache(maxsize=1) |
| def _all_links() -> dict[str, dict[str, str]]: |
| out: dict[str, dict[str, str]] = {} |
| with open(LINE_DIR / "links_2025h1.csv", encoding="utf-8") as f: |
| for r in csv.DictReader(f): |
| out.setdefault(r["date"], {})[r["arriving"]] = r["forms"] |
| return out |
|
|
|
|
| @lru_cache(maxsize=1) |
| def runtimes() -> dict: |
| return json.loads((LINE_DIR / "runtimes.json").read_text()) |
|
|
|
|
| def disruptions() -> list[dict]: |
| with open(LINE_DIR / "disruptions_2025h1.csv", encoding="utf-8") as f: |
| return list(csv.DictReader(f)) |
|
|
|
|
| def days() -> list[str]: |
| return sorted(_all_services()) |
|
|
|
|
| def span_minutes(net: Network, kind: str, a: str, b: str) -> int: |
| """Minimum running minutes between consecutive scheduled stops a and b.""" |
| rt = runtimes() |
| hit = rt.get(kind, {}).get(f"{a}>{b}") |
| if hit: |
| return int(hit["min"]) |
| |
| route = [c for c in net.route(a, b) if net.by_code[c].kind != "junction"] |
| total = 0 |
| for x, y in zip(route, route[1:]): |
| leg = rt["stop"].get(f"{x}>{y}") |
| if leg is None: |
| raise KeyError(f"no running time for {kind} {a}>{b}") |
| total += int(leg["min"]) |
| return max(1, total - (len(route) - 2)) |
|
|
|
|
| def clean_stops(net: Network, s: Service) -> list[Stop]: |
| """The service's stops in route order with both times where it calls on the way. On disrupted days the record |
| holds services changed on the day: an extra stop with only one time, or stops listed out of order.""" |
| timed = sorted(s.stops, key=lambda st: st.sd if st.sd is not None else (st.sa if st.sa is not None else 10**9)) |
| first, last = timed[0].code, timed[-1].code |
| d = net.direction(first, last) |
| seen: dict[str, Stop] = {} |
| for st in s.stops: |
| seen.setdefault(st.code, st) |
| out = sorted(seen.values(), key=lambda st: d * net.index[st.code]) |
| for i, st in enumerate(out): |
| if 0 < i < len(out) - 1: |
| if st.sa is None: |
| st.sa = st.sd |
| if st.sd is None: |
| st.sd = st.sa |
| if out[0].sd is None: |
| out[0].sd = out[0].sa |
| if out[-1].sa is None: |
| out[-1].sa = out[-1].sd |
| times = [t for st in out for t in (st.sa, st.sd) if t is not None] |
| if any(b < a for a, b in zip(times, times[1:])): |
| raise ValueError(f"service {s.train}: times not in route order") |
| return out |
|
|
|
|
| def make_run(net: Network, s: Service, unit: str = "") -> Run: |
| stops_rec = clean_stops(net, s) |
| codes = [st.code for st in stops_rec] |
| route = net.route(codes[0], codes[-1]) |
| stop_at = {st.code: st for st in stops_rec} |
| n = len(route) |
| stops = [c in stop_at for c in route] |
| arr: list[int | None] = [None] * n |
| dep: list[int | None] = [None] * n |
| seg = [0] * (n - 1) |
| idx = [i for i in range(n) if stops[i]] |
| for i in idx: |
| st = stop_at[route[i]] |
| arr[i] = st.sa if i > 0 else None |
| dep[i] = st.sd if i < n - 1 else None |
| for ia, ib in zip(idx, idx[1:]): |
| a, b = stop_at[route[ia]], stop_at[route[ib]] |
| t_min = span_minutes(net, s.kind, route[ia], route[ib]) |
| t_sched = (b.sa if b.sa is not None else b.sd) - (a.sd if a.sd is not None else a.sa) |
| ka, kb = net.by_code[route[ia]].km, net.by_code[route[ib]].km |
| cum = [round(t_min * abs(net.by_code[route[i]].km - ka) / abs(kb - ka)) for i in range(ia, ib + 1)] |
| for j in range(1, len(cum)): |
| cum[j] = max(cum[j], cum[j - 1] + 1) |
| for j in range(ia, ib): |
| seg[j] = cum[j - ia + 1] - cum[j - ia] |
| t0 = a.sd if a.sd is not None else a.sa |
| for i in range(ia + 1, ib): |
| arr[i] = dep[i] = t0 + round(t_sched * abs(net.by_code[route[i]].km - ka) / abs(kb - ka)) |
| return Run(id=s.train, kind=s.kind, route=route, stops=stops, arr=arr, dep=dep, seg=seg, unit=unit) |
|
|
|
|
| @lru_cache(maxsize=64) |
| def load_day(date: str) -> Day: |
| net = load_network() |
| services = dict(_all_services()[date]) |
| for t in list(services): |
| try: |
| clean_stops(net, services[t]) |
| except ValueError: |
| del services[t] |
| links = {a: f for a, f in _all_links().get(date, {}).items() if a in services and f in services} |
| day = Day(date, services, links) |
| formed = set(links.values()) |
| starts = sorted((t for t in services if t not in formed), key=lambda t: services[t].stops[0].sd or 0) |
| for k, t in enumerate(starts): |
| chain = [t] |
| while chain[-1] in links: |
| chain.append(links[chain[-1]]) |
| day.chains.append(chain) |
| for x in chain: |
| day.runs[x] = make_run(net, services[x], unit=f"T{k + 1:02d}") |
| return day |
|
|
