Implement schedule (#34)

* Add initial models for schedule

* Add the transformations

* exclude slot count

* Rename room -> rooms, and str -> list[str] for consistency

* add slugs as well

* Handle half-day workshops as well

Author: egeakman

src/download.py

@@ -12,6 +12,7 @@
 }
 
 base_url = f"https://pretalx.com/api/events/{Config.event}/"
+schedule_url = base_url + "schedules/latest/"
 
 resources = [
     # Questions need to be passed to include answers in the same endpoint,
@@ -50,3 +51,17 @@
 
     with open(filepath, "w") as fd:
         json.dump(res0, fd)
+
+
+# Download schedule
+response = requests.get(schedule_url, headers=headers)
+
+if response.status_code != 200:
+    raise Exception(f"Error {response.status_code}: {response.text}")
+
+data = response.json()
+filename = "schedule_latest.json"
+filepath = Config.raw_path / filename
+
+with open(filepath, "w") as fd:
+    json.dump(data, fd)

src/misc.py

@@ -24,3 +24,33 @@ class SubmissionState(Enum):
     rejected = "rejected"
     canceled = "canceled"
     submitted = "submitted"
+
+
+class Room(Enum):
+    """
+    Rooms at the conference venue, this can change year to year
+    """
+
+    # Tutorial/workshop rooms
+    club_a = "Club A"
+    club_b = "Club B"
+    club_c = "Club C"
+    club_d = "Club D"
+    club_e = "Club E"
+    club_h = "Club H"
+
+    # Conference rooms
+    forum_hall = "Forum Hall"
+    terrace_2a = "Terrace 2A"
+    terrace_2b = "Terrace 2B"
+    north_hall = "North Hall"
+    south_hall_2a = "South Hall 2A"
+    south_hall_2b = "South Hall 2B"
+    main_hall_a = "Main Hall A"
+    main_hall_b = "Main Hall B"
+    main_hall_c = "Main Hall C"
+
+
+class EventType(Enum):
+    SESSION = "session"
+    BREAK = "break"

src/models/europython.py

@@ -1,9 +1,11 @@
-from datetime import datetime
+from __future__ import annotations
+
+from datetime import date, datetime
 
 from pydantic import BaseModel, Field, computed_field, model_validator
 
 from src.config import Config
-from src.misc import SpeakerQuestion, SubmissionQuestion
+from src.misc import EventType, Room, SpeakerQuestion, SubmissionQuestion
 from src.models.pretalx import PretalxAnswer
 
 
@@ -139,6 +141,7 @@ class EuroPythonSession(BaseModel):
     sessions_before: list[str] | None = None
     next_session: str | None = None
     prev_session: str | None = None
+    slot_count: int = Field(..., exclude=True)
 
     @computed_field
     def website_url(self) -> str:
@@ -166,3 +169,66 @@ def extract_answers(cls, values) -> dict:
                 values["level"] = answer.answer_text.lower()
 
         return values
+
+
+class EuroPythonScheduleSession(BaseModel):
+    """
+    Model for EuroPython schedule session data
+    """
+
+    event_type: EventType = EventType.SESSION
+    code: str
+    slug: str
+    title: str
+    session_type: str
+    speakers: list[dict[str, str]]  # code, name, website_url
+    tweet: str
+    level: str
+    total_duration: int = Field(..., exclude=True)
+    rooms: list[Room]
+    start: datetime
+    slot_count: int = Field(..., exclude=True)
+    website_url: str
+
+    @computed_field
+    def duration(self) -> int:
+        return self.total_duration // self.slot_count
+
+
+class EuroPythonScheduleBreak(BaseModel):
+    """
+    Model for EuroPython schedule break data
+    """
+
+    event_type: EventType = EventType.BREAK
+    title: str
+    duration: int
+    rooms: list[Room]
+    start: datetime
+
+
+class DaySchedule(BaseModel):
+    rooms: list[Room]
+    events: list[EuroPythonScheduleSession | EuroPythonScheduleBreak]
+
+
+class Schedule(BaseModel):
+    days: dict[date, DaySchedule]
+
+    @classmethod
+    def from_events(
+        cls, events: list[EuroPythonScheduleSession | EuroPythonScheduleBreak]
+    ) -> Schedule:
+        day_dict = {}
+        for event in events:
+            event_date = event.start.date()
+            if event_date not in day_dict:
+                day_dict[event_date] = {"rooms": list(set(event.rooms)), "events": []}
+            else:
+                day_dict[event_date]["rooms"] = list(
+                    set(day_dict[event_date]["rooms"] + event.rooms)
+                )
+            day_dict[event_date]["events"].append(event)
+
+        day_schedule_dict = {k: DaySchedule(**v) for k, v in day_dict.items()}
+        return cls(days=day_schedule_dict)

src/models/pretalx.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import Any
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
@@ -65,6 +66,7 @@ class PretalxSubmission(BaseModel):
     resources: list[dict[str, str]] | None = None
     answers: list[PretalxAnswer]
     slot: PretalxSlot | None = Field(..., exclude=True)
+    slot_count: int = Field(..., exclude=True)
 
     # Extracted from slot data
     room: str | None = None
@@ -107,3 +109,40 @@ def process_values(cls, values) -> dict:
     @property
     def is_publishable(self) -> bool:
         return self.state in (SubmissionState.accepted, SubmissionState.confirmed)
+
+
+class PretalxScheduleBreak(BaseModel):
+    """
+    Model for Pretalx schedule break data
+    """
+
+    room: str
+    start: datetime
+    end: datetime
+    description: dict[str, str] | str
+
+    @field_validator("description", mode="before")
+    @classmethod
+    def handle_localized(cls, v) -> str | Any:
+        if isinstance(v, dict):
+            return v.get("en")
+        return v
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_slot_info(cls, values) -> dict:
+        slot = PretalxSlot.model_validate(values)
+        values["room"] = slot.room
+        values["start"] = slot.start
+        values["end"] = slot.end
+
+        return values
+
+
+class PretalxSchedule(BaseModel):
+    """
+    Model for Pretalx schedule data
+    """
+
+    slots: list[PretalxSubmission]
+    breaks: list[PretalxScheduleBreak]

src/transform.py

@@ -14,6 +14,7 @@
     pretalx_speakers = Parse.publishable_speakers(
         Config.raw_path / "speakers_latest.json", pretalx_submissions.keys()
     )
+    pretalx_schedule = Parse.schedule(Config.raw_path / "schedule_latest.json")
 
     print("Computing timing relationships...")
     TimingRelationships.compute(pretalx_submissions.values())
@@ -23,6 +24,9 @@
         pretalx_submissions
     )
     ep_speakers = Transform.pretalx_speakers_to_europython_speakers(pretalx_speakers)
+    ep_schedule = Transform.pretalx_schedule_to_europython_schedule(
+        pretalx_schedule.breaks, ep_sessions, ep_speakers
+    )
 
     # Warn about duplicates if the flag is set
     if len(sys.argv) > 1 and sys.argv[1] == "--warn-dupes":
@@ -36,3 +40,6 @@
     print(f"Writing the data to {Config.public_path}...")
     Utils.write_to_file(Config.public_path / "sessions.json", ep_sessions)
     Utils.write_to_file(Config.public_path / "speakers.json", ep_speakers)
+    Utils.write_to_file(
+        Config.public_path / "schedule.json", ep_schedule, direct_dump=True
+    )

src/utils/parse.py

@@ -2,7 +2,7 @@
 from collections.abc import KeysView
 from pathlib import Path
 
-from src.models.pretalx import PretalxSpeaker, PretalxSubmission
+from src.models.pretalx import PretalxSchedule, PretalxSpeaker, PretalxSubmission
 from src.utils.utils import Utils
 
 
@@ -47,3 +47,17 @@ def publishable_speakers(
             }
 
         return publishable_speakers_by_code
+
+    @staticmethod
+    def schedule(input_file: Path | str) -> PretalxSchedule:
+        """
+        Returns the schedule:
+
+        PretalxSchedule.slots: list[PretalxSubmission]
+        PretalxSchedule.breaks: list[PretalxScheduleBreak]
+        """
+        with open(input_file) as fd:
+            js = json.load(fd)
+            schedule = PretalxSchedule.model_validate(js)
+
+        return schedule

src/utils/transform.py

@@ -1,5 +1,11 @@
-from src.models.europython import EuroPythonSession, EuroPythonSpeaker
-from src.models.pretalx import PretalxSpeaker, PretalxSubmission
+from src.models.europython import (
+    EuroPythonScheduleBreak,
+    EuroPythonScheduleSession,
+    EuroPythonSession,
+    EuroPythonSpeaker,
+    Schedule,
+)
+from src.models.pretalx import PretalxScheduleBreak, PretalxSpeaker, PretalxSubmission
 from src.utils.timing_relationships import TimingRelationships
 from src.utils.utils import Utils
 
@@ -50,6 +56,7 @@ 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,
             )
             ep_sessions[code] = ep_session
 
@@ -81,3 +88,65 @@ def pretalx_speakers_to_europython_speakers(
             ep_speakers[code] = ep_speaker
 
         return ep_speakers
+
+    @staticmethod
+    def pretalx_schedule_to_europython_schedule(
+        breaks: list[PretalxScheduleBreak],
+        ep_sessions: dict[str, EuroPythonSession],
+        ep_speakers: dict[str, EuroPythonSpeaker],
+    ) -> Schedule:
+        """
+        Transforms the given Pretalx schedule to EuroPython schedule
+        """
+
+        speakers_values = ep_speakers.values()
+        speaker_code_to_name = {s.code: s.name for s in speakers_values}
+        speaker_code_to_slug = {s.code: s.slug for s in speakers_values}
+        speaker_code_to_website_url = {s.code: s.website_url for s in speakers_values}
+
+        # Merge breaks with the same start and end times
+        breaks = Utils.merge_breaks(breaks)
+        ep_breaks = []
+        for title, duration, rooms, start in breaks:
+            ep_break = EuroPythonScheduleBreak(
+                title=title,
+                duration=duration,
+                rooms=rooms,
+                start=start,
+            )
+            ep_breaks.append(ep_break)
+
+        # Split the sessions that covers multiple slots
+        ep_schedule_sessions_split = []
+        for session in ep_sessions.values():
+            # Skip the sessions that are not assigned in the schedule
+            if not session.start or not session.room:
+                continue
+            start_times = Utils.start_times(session)
+            for start_time in start_times:
+                ep_schedule_session = EuroPythonScheduleSession(
+                    code=session.code,
+                    slug=session.slug,
+                    title=session.title,
+                    session_type=session.session_type,
+                    speakers=[
+                        {
+                            "code": speaker_code,
+                            "name": speaker_code_to_name[speaker_code],
+                            "slug": speaker_code_to_slug[speaker_code],
+                            "website_url": speaker_code_to_website_url[speaker_code],
+                        }
+                        for speaker_code in session.speakers
+                    ],
+                    tweet=session.tweet,
+                    level=session.level,
+                    total_duration=int(session.duration),
+                    rooms=[session.room],
+                    start=start_time,
+                    website_url=session.website_url,
+                    slot_count=session.slot_count,
+                )
+
+                ep_schedule_sessions_split.append(ep_schedule_session)
+
+        return Schedule.from_events(ep_breaks + ep_schedule_sessions_split)