Merge PR #1: Integrate cancellations quality scores and beautify arrival charts

This merge integrates the 'orion' group's 'Days without cancellations' quality scores materials from PR #1 and further optimizes the dashboard to support high-fidelity matplotlib renderings with fallback interactive tables.

1. 'Days without cancellations' Integration:
   - Checked out the 'orion/' directory from 'pr-1' containing the core scripts and markdown.
   - Built a brand new dynamic analysis card 'days-with-no-cancellations' that supports both Method 1 (single line daily report) and Method 2 (operator overview horizontal matplotlib plot), responding dynamically to global filters.

2. Visual Beautification of Bus Arrival Cards:
   - Refactored 'bus_arrival_reliability.py' to use the teammates' original matplotlib plotting functions ('plot_segment_times', 'plot_marey', and 'plot_segment_hour_heatmap') rather than generic client-side Recharts.
   - Preserved full accessibility/screen-reader compliance by generating interactive relief tables ('Table') as a dual fallback view on each card.

3. Global Input Wiring:
   - Wired schedule adherence maps and diagrams in 'schedule_adherence_average.py' to global search filters so that any query (e.g. line 480) re-resolves and synchronizes all 11 dashboard cards instantly.

Author: NoamGaash

README.md

@@ -240,3 +240,7 @@ GitHub Actions (`.github/workflows/ci.yml`) runs on every push/PR to `main`:
 a `python` job that `uv sync`s and runs `./dev check` (plus a non-blocking
 `ruff check`), and a `frontend` job that type-checks with `tsc` and runs the
 Playwright suite, uploading the HTML report as an artifact.
+
+## Desired quality checks for the hackathon
+
+https://docs.google.com/spreadsheets/d/1uFikn1oFehRSQzr4VxS09NjVna7_gvvluq2YKs1pl5Y/edit?gid=0#gid=0

analyses/bus_arrival_reliability.py

@@ -35,17 +35,18 @@
     stop_coverage,
 )
 from bus_times.config import DEFAULT_LAG_DAYS, DEFAULT_MIN_SAMPLES
+from bus_times.viz.segment_bars import plot_segment_times
+from bus_times.viz.marey import plot_marey
+from bus_times.viz.heatmap import plot_segment_hour_heatmap
 
 from openbus_hack import (
     AnalysisRequest,
     AnalysisResult,
     OptionSpec,
-    metrics,
-    Point,
-    Series,
+    Table,
     analysis,
-    bar_chart,
-    heatmap,
+    image,
+    metrics,
 )
 from openbus_hack.diskcache import cached
 
@@ -229,24 +230,13 @@ def run_segments(req: AnalysisRequest):
     except NoMatch as exc:
         return _no_match_card(exc)
     aggregated = aggregate_segments(ride_segments, DEFAULT_MIN_SAMPLES).sort_values("segment_index")
-    labels = [f"{r.from_name} ← {r.to_name}" for r in aggregated.itertuples()]
-
-    # Long-format frame bar_chart() expects: one row per (segment, {Actual, Planned}).
-    # Only the "Actual" rows carry a p25/p75 whisker — "Planned" is a single number,
-    # nothing to spread.
-    long = pd.DataFrame({
-        "segment": [*labels, *labels],
-        "kind": ["Actual (median)"] * len(aggregated) + ["Planned"] * len(aggregated),
-        "minutes": [*(aggregated["actual_median_s"] / 60), *(aggregated["planned_duration_s"] / 60)],
-        "p25": [*(aggregated["actual_p25_s"] / 60), *([None] * len(aggregated))],
-        "p75": [*(aggregated["actual_p75_s"] / 60), *([None] * len(aggregated))],
-    })
 
     weak = int((~aggregated["is_reliable"]).sum())
     notes = [
         quality_summary(aggregated),
         "The whisker on each Actual bar is the ride-to-ride interquartile spread "
         "(p25-p75), not a plain min-max range.",
+        "Toggle 'Table view' at the top-right of the card to see exact numeric median and percentile values.",
         _CREDIT,
     ]
     if weak:
@@ -255,14 +245,25 @@ def run_segments(req: AnalysisRequest):
                         "'not enough evidence'.")
     notes = [*_match_notes(line, alts), *notes]
 
-    return bar_chart(
-        long, x="segment", y="minutes", series="kind", low="p25", high="p75", horizontal=True,
-        title="Where the timetable is optimistic",
-        subtitle=f"{line.label} · {subtitle}",
-        x_label="segment", y_label="minutes",
-        notes=notes,
+    t = Table(
+        columns=["segment", "actual_median_min", "actual_p25_min", "actual_p75_min", "planned_duration_min"],
+        rows=[
+            [
+                f"{r.from_name} ← {r.to_name}",
+                round(r.actual_median_s / 60, 2),
+                round(r.actual_p25_s / 60, 2),
+                round(r.actual_p75_s / 60, 2),
+                round(r.planned_duration_s / 60, 2),
+            ]
+            for r in aggregated.itertuples()
+        ]
     )
 
+    fig = plot_segment_times(aggregated, line.label, subtitle, mode="light", stops_on_x=False)
+    res = image(fig, title="Where the timetable is optimistic", subtitle=f"{line.label} · {subtitle}", notes=notes)
+    res.table = t
+    return res
+
 
 @analysis(
     name="bus-marey-diagram",
@@ -283,61 +284,42 @@ def run_marey(req: AnalysisRequest):
     actual, planned = elapsed_profiles(stop_events)
     coverage = stop_coverage(stop_events)
 
-    planned = planned.sort_values("stop_sequence")
+    planned_sorted = planned.sort_values("stop_sequence")
     coverage_by_seq = coverage.set_index("stop_sequence")["coverage"]
-    y_tick_labels = planned["stop_name"].tolist()
     y_tick_weak = [
         bool(coverage_by_seq.get(seq, 1.0) < _WEAK_COVERAGE)
-        for seq in planned["stop_sequence"]
+        for seq in planned_sorted["stop_sequence"]
     ]
-
-    # Same cap the static chart used (plot_marey's own max_rides default) — past
-    # ~60 overlapping trajectories the fan turns into a solid block and every
-    # extra ride costs payload without adding anything readable.
-    max_rides = 60
-    ride_ids = actual["siri_ride_id"].drop_duplicates().to_numpy()
-    if len(ride_ids) > max_rides:
-        idx = [round(i) for i in _linspace(0, len(ride_ids) - 1, max_rides)]
-        ride_ids = ride_ids[idx]
-
-    series = []
-    for rid in ride_ids:
-        ride = actual[actual["siri_ride_id"] == rid].sort_values("stop_sequence")
-        series.append(Series(
-            name=f"ride_{rid}",
-            points=[Point(x=float(r.elapsed_min), y=float(r.stop_sequence))
-                    for r in ride.itertuples() if pd.notna(r.elapsed_min)],
-        ))
-    series.append(Series(
-        name="Planned",
-        emphasis=True,
-        points=[Point(x=float(r.elapsed_min), y=float(r.stop_sequence))
-                for r in planned.itertuples()],
-    ))
-
     n_weak = sum(y_tick_weak)
+
     notes = [
         "Each faint line is one sampled ride; the bold dashed line is the schedule. "
         "Steep = moving, flat = stuck, and the width of the fan is the route's "
         "unreliability.",
+        "Toggle 'Table view' to see the scheduled elapsed running time per stop sequence.",
         _CREDIT,
     ]
     if n_weak:
-        weak_names = [name for name, w in zip(y_tick_labels, y_tick_weak) if w][:5]
+        weak_names = [name for name, w in zip(planned_sorted["stop_name"], y_tick_weak) if w][:5]
         more = f" (+{n_weak - 5} more)" if n_weak > 5 else ""
         notes.insert(1, f"Dimmed, italic stop labels ({n_weak} of them) are stops the GPS "
                         f"rarely resolved, incl. {', '.join(weak_names)}{more} — trajectories "
                         "through them are interpolation more than measurement.")
 
     notes = [*_match_notes(line, alts), *notes]
-    return AnalysisResult(
-        kind="chart", chart_type="trajectories", series=series,
-        title="Where the bus loses time",
-        subtitle=f"{line.label} · {subtitle}",
-        x_label="elapsed minutes", y_label=None,
-        y_tick_labels=y_tick_labels, y_tick_weak=y_tick_weak,
-        notes=notes,
-    ).ensure_table()
+
+    t = Table(
+        columns=["stop_sequence", "stop_name", "planned_elapsed_min"],
+        rows=[
+            [int(r.stop_sequence), r.stop_name, round(r.elapsed_min, 2)]
+            for r in planned_sorted.itertuples()
+        ]
+    )
+
+    fig = plot_marey(*elapsed_profiles(stop_events), line.label, subtitle, mode="light", coverage=coverage, stops_on_x=False)
+    res = image(fig, title="Where the bus loses time", subtitle=f"{line.label} · {subtitle}", notes=notes)
+    res.table = t
+    return res
 
 
 def _linspace(start: float, stop: float, num: int) -> list[float]:
@@ -363,27 +345,29 @@ def run_heatmap(req: AnalysisRequest):
         line, _stop_events, ride_segments, subtitle, alts = _fetch(req)
     except NoMatch as exc:
         return _no_match_card(exc)
+    matrix_data = segment_hour_matrix(ride_segments)
     matrix = segment_hour_matrix(ride_segments, DEFAULT_MIN_SAMPLES)
-    # matrix.ratio is indexed by (segment_index, from_name, to_name); the segment
-    # pair is what a reader actually recognises, so label rows with that.
     labels = [f"{from_name} ← {to_name}" for _, from_name, to_name in matrix.ratio.index]
-    return heatmap(
-        matrix.ratio,
-        matrix.count,
-        row_labels=labels,
-        col_labels=[f"{int(h):02d}" for h in matrix.ratio.columns],
-        min_count=DEFAULT_MIN_SAMPLES,
-        center=1.0,
-        title="Which segments break down at rush hour",
-        subtitle=f"{line.label} · {subtitle}",
-        row_axis_label="segment",
-        col_axis_label="departure hour",
-        value_label="actual / planned",
-        notes=[
-            *_match_notes(line, alts),
-            "1.00 means exactly on schedule; above that the segment ran longer than "
-            "the timetable allows. Hatched cells are measured but rest on fewer than "
-            f"{DEFAULT_MIN_SAMPLES} rides; empty cells had no usable ride at all.",
-            _CREDIT,
-        ],
+    cols = [f"{int(h):02d}" for h in matrix.ratio.columns]
+
+    notes = [
+        *_match_notes(line, alts),
+        "1.00 means exactly on schedule; above that the segment ran longer than "
+        "the timetable allows. Hatched cells are measured but rest on fewer than "
+        f"{DEFAULT_MIN_SAMPLES} rides; empty cells had no usable ride at all.",
+        "Toggle 'Table view' at the top-right of the card to see the precise ratio values.",
+        _CREDIT,
+    ]
+
+    t = Table(
+        columns=["segment", *cols],
+        rows=[
+            [labels[i], *(None if pd.isna(val) else round(val, 2) for val in matrix.ratio.iloc[i])]
+            for i in range(len(labels))
+        ]
     )
+
+    fig = plot_segment_hour_heatmap(matrix_data, line.label, subtitle, min_samples=DEFAULT_MIN_SAMPLES, mode="light", stops_on_x=False)
+    res = image(fig, title="Which segments break down at rush hour", subtitle=f"{line.label} · {subtitle}", notes=notes)
+    res.table = t
+    return res

analyses/days_with_no_cancellations.py

@@ -0,0 +1,131 @@
+"""Days without cancellations quality score dashboard card.
+
+Integrates the "orion" group materials from orion/days_with_no_cancellations.py.
+"""
+
+from __future__ import annotations
+
+import base64
+import datetime
+import pandas as pd
+
+from openbus_hack import (
+    AnalysisRequest,
+    AnalysisResult,
+    Table,
+    analysis,
+    bar_chart,
+    metrics,
+)
+from orion.days_with_no_cancellations import (
+    daily_report,
+    operator_line_scores,
+    plot_operator_scores,
+)
+
+
+@analysis(
+    name="days-with-no-cancellations",
+    title="Days with zero cancellations",
+    description="Quality score based on how many days all buses operated as expected (zero cancellations). "
+                "A day with >=1 cancellation counts as 0, a day with full operations is 1.",
+    author="orion",
+    tags=["reliability", "cancellations", "data.gov.il"],
+    inputs=["lines", "operators", "dates"],
+)
+def run(req: AnalysisRequest):
+    days_back = 15  # Core metric looks at last 15 days
+    # Default window end date (retaining LAG_DAYS to be consistent with data freshness)
+    end_date = min(req.date_to, datetime.date.today() - datetime.timedelta(days=1))
+
+    # ── Method 1: Single Line ────────────────────────────────────────────────
+    if req.line:
+        operators = req.operators if req.operators else None
+        df = daily_report(req.line, days=days_back, end=end_date, operators=operators)
+        if df.empty:
+            return metrics(
+                ("No data", 0),
+                notes=[
+                    f"No planned rides for line {req.line} in the last {days_back} days.",
+                    "Ensure you have selected the correct operator or clear filters.",
+                ]
+            )
+
+        # Reshape to long format for bar_chart (Operated vs Cancelled)
+        df["date_str"] = df["date"].astype(str)
+        df["Operated"] = df["planned"] - df["cancelled"]
+        df_long = df.melt(
+            id_vars="date_str",
+            value_vars=["Operated", "cancelled"],
+            var_name="Status",
+            value_name="rides",
+        )
+
+        good_days = int(df["good"].sum())
+        total_days = len(df)
+        score = good_days / total_days if total_days > 0 else 0.0
+
+        return bar_chart(
+            df_long,
+            x="date_str",
+            y="rides",
+            series="Status",
+            stacked=True,
+            title=f"Line {req.line} — Daily cancellations and runs",
+            subtitle=f"Score: {score:.2f} ({good_days}/{total_days} clean days in the last {days_back} days)",
+            notes=[
+                "A 'clean day' is one with absolutely zero cancellations.",
+                "Data source is the Ministry's rides execution endpoint (/rides_execution/list), "
+                "where scheduled departures with no matching GPS arrival record represent cancellations.",
+            ],
+        )
+
+    # ── Method 2: Operator Overview ──────────────────────────────────────────
+    else:
+        operator = req.operator or "סופרבוס"  # Fallback to Superbus
+        scores = operator_line_scores(
+            operator, days=days_back, end=end_date, max_lines=15, progress=False
+        )
+        if scores.empty:
+            return metrics(
+                ("No data", 0),
+                notes=[f"No lines with planned rides found for operator {operator}."]
+            )
+
+        # Generate horizontal bar chart using the custom matplotlib plotter
+        fig_path = plot_operator_scores(scores, operator, days=days_back)
+
+        # Read the written file directly as bytes to avoid re-rendering
+        png_bytes = fig_path.read_bytes()
+        b64_str = base64.b64encode(png_bytes).decode("ascii")
+
+        # Expose precise numbers as the relief table
+        t = Table(
+            columns=["line", "score", "good_days", "days_scored", "planned", "cancelled"],
+            rows=[
+                [
+                    row.line,
+                    f"{row.score:.2f}",
+                    int(row.good_days),
+                    int(row.days_scored),
+                    int(row.planned),
+                    int(row.cancelled),
+                ]
+                for row in scores.itertuples()
+            ],
+        )
+
+        return AnalysisResult(
+            kind="image",
+            title=f"{operator} — Days without cancellations",
+            subtitle=f"Scores for worst performing lines, last {days_back} days",
+            image_png=b64_str,
+            image_alt=f"{operator} cancellation scores",
+            table=t,
+            notes=[
+                "Each bar represents the fraction of days (out of last 15) with zero cancellations.",
+                "Hatched bars ('///') indicate lines with zero actual GPS reports, which represent data gaps rather than actual 100% cancellations.",
+                "Toggle 'Table view' at the top-right of the card to see exact planned, operated, and cancelled counts for each line.",
+                f"Data retrieved live from /rides_execution/list.",
+            ],
+        )