Handle partially scheduled Pretalx multi-slot sessions

egeakman · egeakman · commit 676d1252f058 · 2026-06-01T21:24:30.000+02:00
diff --git a/src/models/europython.py b/src/models/europython.py
@@ -323,6 +323,7 @@ class EuroPythonSession(BaseModel):
     next_session: str | None = None
     prev_session: str | None = None
     slot_count: int = Field(..., exclude=True)
+    scheduled_slot_starts: list[datetime] = Field(default_factory=list, exclude=True)
     youtube_url: str | None = None
 
     @field_validator("room", mode="before")
diff --git a/src/models/pretalx.py b/src/models/pretalx.py
@@ -103,14 +103,17 @@ def process_values(cls, values) -> dict:
             ]
             values["resources"] = resources
 
-        # Set slot information
+        # Set slot information from scheduled slots. Pretalx may include empty
+        # placeholder slots for multi-slot submissions.
         if values.get("slots"):
-            first_slot = PretalxSlot.model_validate(values["slots"][0])
-            values["room"] = first_slot.room
-            values["start"] = first_slot.start
+            slots = [PretalxSlot.model_validate(slot) for slot in values["slots"]]
 
-            last_slot = PretalxSlot.model_validate(values["slots"][-1])
-            values["end"] = last_slot.end
+            if start_slot := next((slot for slot in slots if slot.start), None):
+                values["room"] = start_slot.room
+                values["start"] = start_slot.start
+
+            if end_slot := next((slot for slot in reversed(slots) if slot.end), None):
+                values["end"] = end_slot.end
 
         return values
 
diff --git a/src/utils/timing_relationships.py b/src/utils/timing_relationships.py
@@ -14,28 +14,38 @@ class TimingRelationships:
     def compute(
         cls, all_sessions: ValuesView[PretalxSubmission] | list[PretalxSubmission]
     ) -> None:
-        for session in all_sessions:
+        cls.all_sessions_in_parallel = {}
+        cls.all_sessions_after = {}
+        cls.all_sessions_before = {}
+        cls.all_next_session = {}
+        cls.all_prev_session = {}
+
+        timed_sessions = [
+            session for session in all_sessions if session.start and session.end
+        ]
+
+        for session in timed_sessions:
             if not session.start or not session.end:
                 continue
 
             sessions_in_parallel = cls.compute_sessions_in_parallel(
-                session, all_sessions
+                session, timed_sessions
             )
             sessions_after = cls.compute_sessions_after(
-                session, all_sessions, sessions_in_parallel
+                session, timed_sessions, sessions_in_parallel
             )
             sessions_before = cls.compute_sessions_before(
-                session, all_sessions, sessions_in_parallel
+                session, timed_sessions, sessions_in_parallel
             )
 
             cls.all_sessions_in_parallel[session.code] = sessions_in_parallel
             cls.all_sessions_after[session.code] = sessions_after
             cls.all_sessions_before[session.code] = sessions_before
             cls.all_next_session[session.code] = cls.compute_prev_or_next_session(
-                session, sessions_after, all_sessions
+                session, sessions_after, timed_sessions
             )
             cls.all_prev_session[session.code] = cls.compute_prev_or_next_session(
-                session, sessions_before, all_sessions
+                session, sessions_before, timed_sessions
             )
 
     @classmethod
@@ -70,7 +80,9 @@ def compute_sessions_in_parallel(
             if (
                 other_session.code == session.code
                 or other_session.start is None
+                or other_session.end is None
                 or session.start is None
+                or session.end is None
             ):
                 continue
 
diff --git a/src/utils/transform.py b/src/utils/transform.py
@@ -59,6 +59,11 @@ def pretalx_submissions_to_europython_sessions(
                 next_session=TimingRelationships.get_next_session(submission.code),
                 prev_session=TimingRelationships.get_prev_session(submission.code),
                 slot_count=submission.slot_count,
+                scheduled_slot_starts=[
+                    slot.start
+                    for slot in submission.slots
+                    if slot.start and slot.end and slot.room
+                ],
                 youtube_url=youtube_data.get(submission.code),
             )
             ep_sessions[code] = ep_session
diff --git a/src/utils/utils.py b/src/utils/utils.py
@@ -147,6 +147,9 @@ def start_times(session: EuroPythonSession) -> list[datetime]:
 
         TODO: We assume a lot of things here, IMHO we should make things more flexible :)
         """
+        if session.scheduled_slot_starts:
+            return session.scheduled_slot_starts
+
         if session.slot_count == 2:
             # Half day sessions have 2 slots, 90 minutes each, with a 15-minute break in between
             return [session.start, session.start + timedelta(minutes=90 + 15)]
diff --git a/tests/test_timing_relationships.py b/tests/test_timing_relationships.py
@@ -0,0 +1,108 @@
+from src.models.pretalx import PretalxSubmission
+from src.utils.timing_relationships import TimingRelationships
+from src.utils.transform import Transform
+from src.utils.utils import Utils
+
+
+def submission(
+    code: str,
+    start: str | None,
+    end: str | None,
+    room: str | None = "Room A",
+    slots: list[dict] | None = None,
+) -> PretalxSubmission:
+    return PretalxSubmission.model_validate(
+        {
+            "code": code,
+            "title": code,
+            "speakers": [],
+            "submission_type": "Talk",
+            "state": "confirmed",
+            "answers": [],
+            "slot_count": len(slots) if slots else 1,
+            "slots": slots
+            if slots is not None
+            else [{"room": room, "start": start, "end": end}],
+        }
+    )
+
+
+def test_submission_uses_last_timed_slot_before_blank_placeholders() -> None:
+    session = submission(
+        "BTTFFJ",
+        None,
+        None,
+        slots=[
+            {
+                "room": "Reception Room F2 (Fishbowl)",
+                "start": "2026-07-14T09:30:00+02:00",
+                "end": "2026-07-14T11:00:00+02:00",
+            },
+            {
+                "room": "Reception Room F2 (Fishbowl)",
+                "start": "2026-07-14T11:15:00+02:00",
+                "end": "2026-07-14T12:45:00+02:00",
+            },
+            {"room": None, "start": None, "end": None},
+            {"room": None, "start": None, "end": None},
+        ],
+    )
+
+    assert session.room == "Reception Room F2 (Fishbowl)"
+    assert session.start.isoformat() == "2026-07-14T09:30:00+02:00"
+    assert session.end.isoformat() == "2026-07-14T12:45:00+02:00"
+
+
+def test_timing_relationships_ignore_partial_sessions_and_reset_state() -> None:
+    first = submission(
+        "FIRST", "2026-07-14T09:30:00+02:00", "2026-07-14T10:30:00+02:00"
+    )
+    parallel = submission(
+        "PARALLEL",
+        "2026-07-14T10:00:00+02:00",
+        "2026-07-14T11:00:00+02:00",
+        room="Room B",
+    )
+    partial = submission("PARTIAL", "2026-07-14T10:15:00+02:00", None)
+
+    TimingRelationships.compute([first, parallel, partial])
+
+    assert TimingRelationships.get_sessions_in_parallel("FIRST") == ["PARALLEL"]
+    assert TimingRelationships.get_sessions_in_parallel("PARTIAL") is None
+
+    TimingRelationships.compute([partial])
+
+    assert TimingRelationships.get_sessions_in_parallel("FIRST") is None
+
+
+def test_schedule_start_times_use_only_scheduled_slots() -> None:
+    session = submission(
+        "BTTFFJ",
+        None,
+        None,
+        slots=[
+            {
+                "room": "Reception Room F2 (Fishbowl)",
+                "start": "2026-07-14T09:30:00+02:00",
+                "end": "2026-07-14T11:00:00+02:00",
+            },
+            {
+                "room": "Reception Room F2 (Fishbowl)",
+                "start": "2026-07-14T11:15:00+02:00",
+                "end": "2026-07-14T12:45:00+02:00",
+            },
+            {"room": None, "start": None, "end": None},
+            {"room": None, "start": None, "end": None},
+        ],
+    )
+    session.slot_count = 4
+
+    TimingRelationships.compute([session])
+    ep_session = Transform.pretalx_submissions_to_europython_sessions(
+        {session.code: session}, {}
+    )[session.code]
+
+    assert [dt.isoformat() for dt in Utils.start_times(ep_session)] == [
+        "2026-07-14T09:30:00+02:00",
+        "2026-07-14T11:15:00+02:00",
+    ]
