refactor: integrate events_df for event processing and filtering

app.py

@@ -32,6 +32,7 @@ from src.ui.view import (
     toggle_filter_popover,
     view_updates,
 )
+from src.ui.events_df import events_df
 
 load_env()
 
@@ -47,7 +48,8 @@ def render():
         pull_events(EVENTS_PATH)
     payload = load_payload(EVENTS_PATH)
     results = normalize_results(payload["results"])
-    category_choices, tag_choices, org_choices = facet_choices(results)
+    df_all = events_df(results)
+    category_choices, tag_choices, org_choices = facet_choices(df_all)
     summary, spotlight, table, button_label, clear_button = view_updates(
         results,
         categories=category_choices,

src/attending.py

@@ -1,16 +1,11 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
 from html import escape
 from urllib.parse import quote
 
 import pandas as pd
 
 from .config import local_display_tz
-from .events_schema import normalize_results
-from .models import parse_dt_utc
-from .teams_calendar import event_key
-
 LOCAL_DISPLAY_TZ = local_display_tz()
 WHEN_COL = "When"
 COLS = [WHEN_COL, "Event", "Speaker", "Category", "Organization", "Calendar"]
@@ -62,74 +57,26 @@ def share_button(anchor_id: str) -> str:
     )
 
 
-def filtered_events(
-    results: list[dict],
-    query: str = "",
-    categories: Sequence[str] | None = None,
-    tags: Sequence[str] | None = None,
-    orgs: Sequence[str] | None = None,
-) -> list[tuple[int, int, dict, dict]]:
-    normalize_results(results)
-    now = pd.Timestamp.now(tz=LOCAL_DISPLAY_TZ)
-    needle = query.strip().lower()
-    category_filter = None if categories is None else set(categories)
-    tag_filter = None if tags is None else set(tags)
-    org_filter = None if orgs is None else set(orgs)
-    matches: list[tuple[object, str, int, int, dict, dict]] = []
-    for result_index, result in enumerate(results):
-        if result["status"] != "ok":
-            continue
-        for event_index, event in enumerate(result["events"]):
-            start_time = pd.Timestamp(parse_dt_utc(event["start_time"])).tz_convert(LOCAL_DISPLAY_TZ)
-            if start_time <= now - pd.Timedelta(hours=1):
-                continue
-            if category_filter is not None and event["category"] not in category_filter:
-                continue
-            if org_filter is not None and result["org_name"] not in org_filter:
-                continue
-            if tag_filter is not None and not tag_filter.intersection(event["tags"]):
-                continue
-            haystack = " ".join(
-                (
-                    result["org_name"],
-                    event["title"],
-                    event["speaker"],
-                    event["affiliation"],
-                    event["category"],
-                    " ".join(event["tags"]),
-                )
-            ).lower()
-            if needle and needle not in haystack:
-                continue
-            matches.append((start_time, result["org_name"], result_index, event_index, result, event))
-
-    return [
-        (result_index, event_index, result, event)
-        for _, _, result_index, event_index, result, event in sorted(matches)
-    ]
-
-
 def results_table(
-    results: list[dict],
+    df_filtered: pd.DataFrame,
     colors: dict[str, str],
-    query: str = "",
-    categories: Sequence[str] | None = None,
-    tags: Sequence[str] | None = None,
-    orgs: Sequence[str] | None = None,
 ) -> pd.DataFrame:
+    if df_filtered.empty:
+        return pd.DataFrame(columns=COLS)
+
     rows: list[dict[str, object]] = []
-    for _, _, result, event in filtered_events(results, query, categories, tags, orgs):
-        current_event_key = event_key(result, event)
+    for row in df_filtered.itertuples(index=False):
+        current_event_key = row.event_key
         anchor_id = f"event-{current_event_key}"
-        title = event["title"] or "View event"
-        source_time = format_event_time(event["start_time"])
-        local_time = format_event_time(event["start_time"], tz_name=LOCAL_DISPLAY_TZ)
-        tag_chips = "".join(chip(tag) for tag in event["tags"])
+        title = row.title or "View event"
+        source_time = format_event_time(row.start_time)
+        local_time = format_event_time(row.start_time, tz_name=LOCAL_DISPLAY_TZ)
+        tag_chips = "".join(chip(tag) for tag in (row.tags or []))
         event_cell = (
             f'<a class="event-anchor event-anchor--{anchor_id}" '
-            f'href="{escape(event["event_url"], quote=True)}">'
+            f'href="{escape(row.event_url, quote=True)}">'
             f"{escape(title)}</a>"
-            if event["event_url"]
+            if row.event_url
             else f'<strong class="event-anchor event-anchor--{anchor_id}">{escape(title)}</strong>'
         )
         event_cell = f"{event_cell}{share_button(anchor_id)}"
@@ -139,14 +86,11 @@ def results_table(
             {
                 WHEN_COL: f"**{local_time}**<br><span class='muted-cell'>Source: {source_time}</span>",
                 "Event": event_cell,
-                "Speaker": speaker_cell(event["speaker"], event["affiliation"]),
-                "Category": chip(event["category"], "pill"),
-                "Organization": org_badge(result["org_name"], colors),
-                "Calendar": calendar_badge(current_event_key, event["attending_count"]),
+                "Speaker": speaker_cell(row.speaker, row.affiliation),
+                "Category": chip(row.category, "pill"),
+                "Organization": org_badge(row.org_name, colors),
+                "Calendar": calendar_badge(current_event_key, row.attending_count),
             }
         )
 
-    if not rows:
-        return pd.DataFrame(columns=COLS)
-
     return pd.DataFrame(rows).reset_index(drop=True)[COLS]

src/ui/events_df.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import pandas as pd
+
+from ..attending import LOCAL_DISPLAY_TZ
+from ..events_schema import normalize_results
+from ..models import parse_dt_utc
+from ..teams_calendar import event_key as compute_event_key
+
+
+def events_df(results: list[dict]) -> pd.DataFrame:
+    normalize_results(results)
+    now = pd.Timestamp.now(tz=LOCAL_DISPLAY_TZ)
+
+    rows: list[dict[str, object]] = []
+    for result in results:
+        if result["status"] != "ok":
+            continue
+        for event in result["events"]:
+            start_local = pd.Timestamp(parse_dt_utc(event["start_time"])).tz_convert(LOCAL_DISPLAY_TZ)
+            if start_local <= now - pd.Timedelta(hours=1):
+                continue
+            tags = event["tags"]
+            rows.append(
+                {
+                    "start_local": start_local,
+                    "org_name": result["org_name"],
+                    "source_url": result["source_url"],
+                    "title": event["title"],
+                    "start_time": event["start_time"],
+                    "event_url": event["event_url"],
+                    "speaker": event["speaker"],
+                    "affiliation": event["affiliation"],
+                    "category": event["category"],
+                    "tags": tags,
+                    "attending_count": event["attending_count"],
+                    "event_key": compute_event_key(result, event),
+                    "haystack": " ".join(
+                        (
+                            result["org_name"],
+                            event["title"],
+                            event["speaker"],
+                            event["affiliation"],
+                            event["category"],
+                            " ".join(tags),
+                        )
+                    ).lower(),
+                }
+            )
+
+    if not rows:
+        return pd.DataFrame(
+            columns=[
+                "start_local",
+                "org_name",
+                "source_url",
+                "title",
+                "start_time",
+                "event_url",
+                "speaker",
+                "affiliation",
+                "category",
+                "tags",
+                "attending_count",
+                "event_key",
+                "haystack",
+            ]
+        )
+
+    df = pd.DataFrame(rows)
+    df = df.sort_values(["start_local", "org_name"], kind="mergesort").reset_index(drop=True)
+    return df
+
+
+def _facet_mask(values: Sequence[str] | None, series: pd.Series) -> pd.Series:
+    if values is None:
+        return pd.Series(True, index=series.index)
+    if not values:
+        return pd.Series(False, index=series.index)
+    return series.isin(list(values))
+
+
+def filter_events_df(
+    df: pd.DataFrame,
+    query: str = "",
+    categories: Sequence[str] | None = None,
+    tags: Sequence[str] | None = None,
+    orgs: Sequence[str] | None = None,
+) -> pd.DataFrame:
+    if df.empty:
+        return df
+
+    mask = pd.Series(True, index=df.index)
+
+    mask &= _facet_mask(categories, df["category"])
+    mask &= _facet_mask(orgs, df["org_name"])
+
+    if tags is None:
+        pass
+    elif not tags:
+        mask &= False
+    else:
+        wanted = set(tags)
+        mask &= df["tags"].apply(lambda row_tags: bool(wanted.intersection(row_tags)))
+
+    needle = query.strip().lower()
+    if needle:
+        mask &= df["haystack"].str.contains(needle, regex=False)
+
+    return df.loc[mask].reset_index(drop=True)
+

src/ui/view.py

@@ -7,12 +7,15 @@ from urllib.parse import urlencode
 import gradio as gr
 from fastapi import Request
 
-from ..attending import LOCAL_DISPLAY_TZ, filtered_events, format_event_time, results_table
+import pandas as pd
+
+from ..attending import LOCAL_DISPLAY_TZ, format_event_time, results_table
 from ..org_colors import org_colors
+from .events_df import events_df, filter_events_df
 
 
 def render_hero(payload: dict, results: list[dict]) -> str:
-    total_events = len(filtered_events(results))
+    total_events = len(events_df(results))
     updated = payload["meta"]["cached_at"]
     return f"""
 <section class="hero-shell">
@@ -29,26 +32,12 @@ def render_hero(payload: dict, results: list[dict]) -> str:
 """
 
 
-def facet_choices(results: list[dict]) -> tuple[list[str], list[str], list[str]]:
-    categories = sorted(
-        {
-            event["category"]
-            for result in results
-            if result["status"] == "ok"
-            for event in result["events"]
-            if event["category"]
-        }
-    )
-    tags = sorted(
-        {
-            tag
-            for result in results
-            if result["status"] == "ok"
-            for event in result["events"]
-            for tag in event["tags"]
-        }
-    )
-    orgs = sorted({result["org_name"] for result in results if result["status"] == "ok"})
+def facet_choices(df_all: "pd.DataFrame") -> tuple[list[str], list[str], list[str]]:
+    if df_all.empty:
+        return [], [], []
+    categories = sorted([value for value in df_all["category"].dropna().unique().tolist() if value])
+    orgs = sorted([value for value in df_all["org_name"].dropna().unique().tolist() if value])
+    tags = sorted([value for value in df_all["tags"].explode().dropna().unique().tolist() if value])
     return categories, tags, orgs
 
 
@@ -100,14 +89,13 @@ def has_active_filters(
 
 
 def render_filter_summary(
-    results: list[dict],
+    total: int,
+    matches: int,
     query: str = "",
     categories: Sequence[str] | None = None,
     tags: Sequence[str] | None = None,
     orgs: Sequence[str] | None = None,
 ) -> str:
-    total = len(filtered_events(results))
-    matches = len(filtered_events(results, query, categories, tags, orgs))
     active = []
     if query.strip():
         active.append("search")
@@ -122,7 +110,7 @@ def render_filter_summary(
 
 
 def render_spotlight(
-    results: list[dict],
+    df_filtered: "pd.DataFrame",
     query: str = "",
     categories: Sequence[str] | None = None,
     tags: Sequence[str] | None = None,
@@ -137,18 +125,20 @@ def render_spotlight(
     cards = [
         f"""
 <article class="spotlight-card">
-  <div class="spotlight-time">{escape(format_event_time(event["start_time"], tz_name=LOCAL_DISPLAY_TZ))}</div>
-  <h3><a href="{escape(event["event_url"] or result["source_url"], quote=True)}">{escape(event["title"] or "View event")}</a></h3>
-  <p>{escape(event["speaker"] or event["affiliation"] or event["category"])}</p>
+  <div class="spotlight-time">{escape(format_event_time(row.start_time, tz_name=LOCAL_DISPLAY_TZ))}</div>
+  <h3><a href="{escape(row.event_url or row.source_url, quote=True)}">{escape(row.title or "View event")}</a></h3>
+  <p>{escape(row.speaker or row.affiliation or row.category)}</p>
   <div>
-    {"".join(f'<span class="tag-chip">{escape(tag)}</span>' for tag in event["tags"][:2])}
-    <span class="tag-chip">{escape(result["org_name"])}</span>
-    <span class="pill">{escape(event["category"])}</span>
+    {"".join(f'<span class="tag-chip">{escape(tag)}</span>' for tag in (row.tags or [])[:2])}
+    <span class="tag-chip">{escape(row.org_name)}</span>
+    <span class="pill">{escape(row.category)}</span>
   </div>
 </article>
 """
-        for _, _, result, event in filtered_events(results, query, categories, tags, orgs)[:3]
-    ] or [f'<p class="empty-state">{escape(empty_state)}</p>']
+        for row in df_filtered.head(3).itertuples(index=False)
+    ]
+    if not cards:
+        cards = [f'<p class="empty-state">{escape(empty_state)}</p>']
     return f"""
 <section class="spotlight-shell">
   <p class="eyebrow">Next up</p>
@@ -157,22 +147,6 @@ def render_spotlight(
 """
 
 
-def build_view(
-    results: list[dict],
-    query: str = "",
-    categories: Sequence[str] | None = None,
-    tags: Sequence[str] | None = None,
-    orgs: Sequence[str] | None = None,
-):
-    colors = org_colors(result["org_name"] for result in results)
-    table = results_table(results, colors, query, categories, tags, orgs)
-    return (
-        render_filter_summary(results, query, categories, tags, orgs),
-        render_spotlight(results, query, categories, tags, orgs),
-        table,
-    )
-
-
 def view_updates(
     results: list[dict],
     query: str = "",
@@ -180,12 +154,17 @@ def view_updates(
     tags: Sequence[str] | None = (),
     orgs: Sequence[str] | None = (),
 ):
-    category_choices, tag_choices, org_choices = facet_choices(results)
+    df_all = events_df(results)
+    category_choices, tag_choices, org_choices = facet_choices(df_all)
     categories = coerce_facet_selection(categories, category_choices)
     tags = coerce_facet_selection(tags, tag_choices)
     orgs = coerce_facet_selection(orgs, org_choices)
 
-    summary, spotlight, table = build_view(results, query, categories, tags, orgs)
+    df_filtered = filter_events_df(df_all, query, categories, tags, orgs)
+    colors = org_colors(df_all["org_name"].tolist())
+    summary = render_filter_summary(len(df_all), len(df_filtered), query, categories, tags, orgs)
+    spotlight = render_spotlight(df_filtered, query, categories, tags, orgs)
+    table = results_table(df_filtered, colors)
     return (
         summary,
         spotlight,
@@ -196,7 +175,8 @@ def view_updates(
 
 
 def reset_filters(results: list[dict]):
-    category_choices, tag_choices, org_choices = facet_choices(results)
+    df_all = events_df(results)
+    category_choices, tag_choices, org_choices = facet_choices(df_all)
     summary, spotlight, table, button_label, clear_button = view_updates(
         results,
         categories=category_choices,

tests/test_golden.py

@@ -5,9 +5,10 @@ import pytest
 from fastapi.testclient import TestClient
 
 import app
-from src.attending import COLS, WHEN_COL, filtered_events, results_table
+from src.attending import COLS, WHEN_COL, results_table
 from src.models import SCHEMA_VERSION, infer_category, load_payload, parse_dt_utc, write_payload
 from src.teams_calendar import PENDING_STATES, SESSION_COOKIE, SESSIONS, ensure_user_on_event, event_key
+from src.ui.events_df import events_df, filter_events_df
 
 
 def sample_results() -> list[dict]:
@@ -170,7 +171,9 @@ def client():
 
 def test_results_table_shows_source_local_time_and_calendar_badge():
     results = sample_results()
-    table = results_table(results, {"CMU": "#000000"})
+    df_all = events_df(results)
+    df_filtered = filter_events_df(df_all)
+    table = results_table(df_filtered, {"CMU": "#000000"})
     current_event_key = first_event_key(results)
 
     assert list(table.columns) == COLS
@@ -189,56 +192,59 @@ def test_results_table_shows_source_local_time_and_calendar_badge():
 
 
 def test_results_table_filters_case_insensitively():
-    table = results_table(searchable_results(), searchable_colors(), query="VISION")
+    df_filtered = filter_events_df(events_df(searchable_results()), query="VISION")
+    table = results_table(df_filtered, searchable_colors())
 
     assert table.shape[0] == 2
     assert "Vision Event" in table.loc[0, "Event"]
     assert "Robot vision in the wild" in table.loc[1, "Event"]
 
 
-def test_filtered_events_none_facets_do_not_filter():
-    matches = filtered_events(searchable_results(), categories=None, tags=None, orgs=None)
+def test_events_df_none_facets_do_not_filter():
+    df = filter_events_df(events_df(searchable_results()), categories=None, tags=None, orgs=None)
 
-    assert [event["title"] for _, _, _, event in matches] == [
+    assert df["title"].tolist() == [
         "Vision Event",
         "Robot vision in the wild",
         "Humanoid Control",
     ]
 
 
-def test_filtered_events_filter_by_category_tag_and_org():
-    matches = filtered_events(
-        searchable_results(), categories=["Lecture"], tags=["vision"], orgs=["Stanford"]
+def test_events_df_filter_by_category_tag_and_org():
+    df = filter_events_df(
+        events_df(searchable_results()), categories=["Lecture"], tags=["vision"], orgs=["Stanford"]
     )
 
-    assert len(matches) == 1
-    assert matches[0][3]["title"] == "Robot vision in the wild"
+    assert df.shape[0] == 1
+    assert df.loc[0, "title"] == "Robot vision in the wild"
 
 
-def test_filtered_events_use_or_within_same_group():
-    matches = filtered_events(searchable_results(), tags=["humanoids", "vision"])
+def test_events_df_use_or_within_same_group():
+    df = filter_events_df(events_df(searchable_results()), tags=["humanoids", "vision"])
 
-    assert [event["title"] for _, _, _, event in matches] == ["Robot vision in the wild", "Humanoid Control"]
+    assert df["title"].tolist() == ["Robot vision in the wild", "Humanoid Control"]
 
 
 def test_results_table_filters_by_category():
-    table = results_table(searchable_results(), searchable_colors(), categories=["Seminar"])
+    df_filtered = filter_events_df(events_df(searchable_results()), categories=["Seminar"])
+    table = results_table(df_filtered, searchable_colors())
 
     assert table.shape[0] == 1
     assert "Vision Event" in table.loc[0, "Event"]
 
 
 def test_results_table_filters_by_university_org():
-    table = results_table(searchable_results(), searchable_colors(), orgs=["Stanford"])
+    df_filtered = filter_events_df(events_df(searchable_results()), orgs=["Stanford"])
+    table = results_table(df_filtered, searchable_colors())
 
     assert table.shape[0] == 1
     assert "Robot vision in the wild" in table.loc[0, "Event"]
 
 
 def test_render_filter_summary_shows_active_filters():
-    summary = app.render_filter_summary(
-        searchable_results(), query="vision", tags=["vision"], orgs=["Stanford"]
-    )
+    df_all = events_df(searchable_results())
+    df_filtered = filter_events_df(df_all, query="vision", tags=["vision"], orgs=["Stanford"])
+    summary = app.render_filter_summary(len(df_all), len(df_filtered), query="vision", tags=["vision"], orgs=["Stanford"])
 
     assert "**1** of **3** upcoming events." in summary
     assert "search" in summary
@@ -251,7 +257,8 @@ def test_filter_button_label_counts_selected_facets():
 
 
 def test_view_updates_treat_full_selection_as_default():
-    categories, tags, orgs = app.facet_choices(searchable_results())
+    df_all = events_df(searchable_results())
+    categories, tags, orgs = app.facet_choices(df_all)
     summary, _, _, button_label, clear_button = app.view_updates(
         searchable_results(),
         categories=categories,
@@ -285,23 +292,24 @@ def test_render_selects_all_filter_choices_by_default(monkeypatch):
 
 
 def test_results_table_returns_empty_columns_when_filter_explicitly_empty():
-    table = results_table(searchable_results(), searchable_colors(), tags=[])
+    df_filtered = filter_events_df(events_df(searchable_results()), tags=[])
+    table = results_table(df_filtered, searchable_colors())
 
     assert table.empty
     assert list(table.columns) == COLS
 
 
 def test_results_table_returns_empty_columns_when_filters_miss():
-    table = results_table(
-        searchable_results(), searchable_colors(), categories=["Seminar"], orgs=["Stanford"]
-    )
+    df_filtered = filter_events_df(events_df(searchable_results()), categories=["Seminar"], orgs=["Stanford"])
+    table = results_table(df_filtered, searchable_colors())
 
     assert table.empty
     assert list(table.columns) == COLS
 
 
 def test_results_table_shows_only_future_events():
-    table = results_table(mixed_results(), {"CMU": "#000000"})
+    df_filtered = filter_events_df(events_df(mixed_results()))
+    table = results_table(df_filtered, {"CMU": "#000000"})
 
     assert table.shape[0] == 1
     assert "Future Event" in table.loc[0, "Event"]
@@ -344,16 +352,15 @@ def test_filtered_events_keep_recently_started_events_visible_for_one_hour():
             "error": None,
         }
     ]
-
-    matches = filtered_events(results)
-
-    assert [event["title"] for _, _, _, event in matches] == ["Just Started"]
+    df_filtered = filter_events_df(events_df(results))
+    assert df_filtered["title"].tolist() == ["Just Started"]
 
 
 def test_render_upcoming_counts_ignore_past_events():
     results = mixed_results()
     hero = app.render_hero({"meta": {"cached_at": "2026-04-12T20:22:12+00:00"}}, results)
-    summary = app.render_filter_summary(results)
+    df_all = events_df(results)
+    summary = app.render_filter_summary(len(df_all), len(df_all))
 
     assert "<strong>1</strong> upcoming" in hero
     assert "**1** of **1** upcoming events." in summary