Updates to full race commentary

reachy_f1_commentator/__init__.py

@@ -11,3 +11,5 @@ __author__ = "Dave Starling"
 from .main import ReachyF1Commentator
 
 __all__ = ["ReachyF1Commentator"]
+
+

reachy_f1_commentator/full_race_mode.py

@@ -101,27 +101,24 @@ class FullRaceMode:
                 playback_speed=self.playback_speed
             )
             
-            # Create OpenF1 client for data ingestion
-            openf1_api_client = OpenF1Client(api_key="")
-            openf1_api_client.authenticate()
-            
             # Create data ingestion module in replay mode
             from .src.config import Config
             from .src.event_queue import PriorityEventQueue
             
             config = Config()
-            event_queue = PriorityEventQueue()
+            config.replay_mode = True  # Enable replay mode
+            config.replay_race_id = self.session_key  # Set the session key
+            config.replay_speed = self.playback_speed  # Set playback speed
+            # skip_large_gaps defaults to True, which is fine now that we handle starting grid -> race start
+            event_queue = PriorityEventQueue(max_size=100)  # Larger queue for replay mode
             
             self.data_ingestion = DataIngestionModule(
                 config=config,
-                openf1_client=openf1_api_client,
                 event_queue=event_queue
             )
             
-            # Set replay mode
-            self.data_ingestion.set_replay_mode(
-                replay_controller=self.replay_controller
-            )
+            # The replay controller will be created by DataIngestionModule
+            # when it starts in replay mode
             
             self._initialized = True
             logger.info("Full Race Mode initialized successfully")
@@ -166,25 +163,47 @@ class FullRaceMode:
             )
             ingestion_thread.start()
             
+            # Give the thread a moment to start
+            time.sleep(0.1)
+            
             # Yield events from queue
+            no_event_count = 0
+            max_no_event_iterations = 600  # Increased to 60 seconds to handle long waits during replay
+            
             while True:
                 try:
-                    # Get event from queue (with timeout)
-                    event = event_queue.get(timeout=1.0)
-                    
-                    if event is None:
-                        # End of race signal
-                        logger.info("End of race reached")
-                        break
+                    # Get event from queue using dequeue()
+                    event = event_queue.dequeue()
                     
-                    yield event
+                    if event is not None:
+                        no_event_count = 0  # Reset counter when we get an event
+                        yield event
+                    else:
+                        # No event available
+                        no_event_count += 1
+                        
+                        # Check if thread is still alive
+                        if not ingestion_thread.is_alive():
+                            # Thread stopped, check if there are any remaining events
+                            remaining_event = event_queue.dequeue()
+                            if remaining_event is None:
+                                logger.info("Ingestion thread stopped and queue is empty")
+                                break
+                            else:
+                                # Still have events, yield them
+                                yield remaining_event
+                                no_event_count = 0
+                        elif no_event_count >= max_no_event_iterations:
+                            logger.warning(f"No events received for {max_no_event_iterations} iterations, stopping")
+                            logger.warning("This may indicate the replay is stuck or has very long gaps between events")
+                            break
+                        else:
+                            # Wait a bit before checking again
+                            time.sleep(0.1)
                     
                 except Exception as e:
-                    # Timeout or other error
-                    if not ingestion_thread.is_alive():
-                        logger.info("Ingestion thread stopped")
-                        break
-                    continue
+                    logger.error(f"Error getting event from queue: {e}", exc_info=True)
+                    break
             
             # Stop ingestion
             self.data_ingestion.stop()

reachy_f1_commentator/main.py

@@ -364,7 +364,12 @@ class ReachyF1Commentator(ReachyMiniApp):
                 # Generate commentary
                 try:
                     commentary = self.commentary_generator.generate(event)
-                    if commentary:  # Only log non-empty commentary
+                    
+                    # Debug: check what we got back
+                    logger.debug(f"Event type: {event.event_type.value}, Commentary: {repr(commentary)[:100]}")
+                    
+                    # Skip empty or whitespace-only commentary
+                    if commentary and isinstance(commentary, str) and commentary.strip():
                         logger.info(f"[Lap {lap_number}] {commentary}")
                         event_count += 1
                         
@@ -385,6 +390,13 @@ class ReachyF1Commentator(ReachyMiniApp):
                                 self.speech_synthesizer.synthesize_and_play(commentary)
                             except Exception as e:
                                 logger.error(f"Audio synthesis error: {e}", exc_info=True)
+                        
+                        # Add a small delay between commentary pieces to prevent queue overflow
+                        # and give more natural pacing. At 1x speed, this ensures we don't
+                        # generate commentary faster than race events occur.
+                        # The delay is scaled by playback speed.
+                        delay = 1.0 / playback_speed  # 1 second at 1x, 0.1s at 10x, 0.05s at 20x
+                        time.sleep(delay)
                                 
                 except Exception as e:
                     logger.error(f"Error generating commentary: {e}", exc_info=True)
@@ -514,8 +526,13 @@ async def get_races(year: int):
         if _app_instance is None:
             raise HTTPException(status_code=503, detail="App not initialized")
         
+        logger.info(f"Fetching races for year {year}")
         races = _app_instance.openf1_client.get_races_by_year(year)
         
+        if not races:
+            logger.warning(f"No races found for year {year}")
+            return {"races": []}
+        
         # Convert to dict format
         races_data = [
             {
@@ -528,10 +545,11 @@ async def get_races(year: int):
             for race in races
         ]
         
+        logger.info(f"Returning {len(races_data)} races for year {year}")
         return {"races": races_data}
     except Exception as e:
-        logger.error(f"Failed to get races for year {year}: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Failed to get races for year {year}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to load races: {str(e)}")
 
 
 @app.post("/api/commentary/start")

reachy_f1_commentator/openf1_client.py

@@ -67,13 +67,23 @@ class OpenF1APIClient:
     def get_years(self) -> List[int]:
         """
         Get list of available years with race data.
+        Only returns years with completed races (excludes current/future years).
         
         Returns:
             List of years in descending order
         """
         try:
+            from datetime import datetime
+            
             races = self.get_race_sessions()
-            years = sorted(set(r.get('year', 0) for r in races if r.get('year')), reverse=True)
+            current_year = datetime.now().year
+            
+            # Filter to only include years before current year
+            # (current year races may not have telemetry data yet)
+            years = sorted(
+                set(r.get('year', 0) for r in races if r.get('year') and r.get('year') < current_year),
+                reverse=True
+            )
             logger.info(f"Found {len(years)} years with race data: {years}")
             return years
         except Exception as e:

reachy_f1_commentator/src/commentary_generator.py

@@ -441,7 +441,7 @@ class CommentaryGenerator:
             style: Commentary style
             
         Returns:
-            Template-based commentary text
+            Template-based commentary text (empty string if event should be skipped)
             
         Validates: Requirement 5.2
         """
@@ -459,6 +459,11 @@ class CommentaryGenerator:
         # Normalize event data for template compatibility
         normalized_data = self._normalize_event_data(event)
         
+        # If normalization returns empty dict, skip this event
+        if not normalized_data:
+            logger.debug(f"Skipping event {event.event_type.value} - no data after normalization")
+            return ""
+        
         # Get additional state data if needed
         state_data = self._get_state_data(event)
         
@@ -602,4 +607,13 @@ class CommentaryGenerator:
                 if grid:
                     data['pole_driver'] = grid[0].get('full_name', 'Unknown')
         
+        # Normalize regular position update data (during race)
+        elif event.event_type == EventType.POSITION_UPDATE:
+            # Position updates are frequent but not very interesting
+            # We'll skip most of them but show occasional updates
+            # For now, skip all non-starting-grid position updates
+            # TODO: Implement logic to show periodic position updates (every 5 laps?)
+            logger.debug("Skipping regular position update (not starting grid)")
+            return {}  # Return empty dict to skip this event
+        
         return data

reachy_f1_commentator/src/data_ingestion.py

@@ -501,6 +501,13 @@ class EventParser:
         """
         Parse race control data to detect flags, safety car, and incidents.
         
+        Filters out boring race control messages and only keeps important ones like:
+        - Race start
+        - Safety car deployment/withdrawal
+        - Red flags
+        - Chequered flag
+        - Major incidents
+        
         Args:
             data: List of race control message dictionaries
             
@@ -520,7 +527,41 @@ class EventParser:
                 category = entry.get('category', '').lower()
                 lap_number = entry.get('lap_number', 1)
                 
-                # Detect flags
+                # Filter out boring messages - only keep important race control events
+                boring_keywords = [
+                    'track limits',
+                    'deleted',
+                    'time',
+                    'under investigation',
+                    'noted',
+                    'reported',
+                    'car stopped',
+                    'drs enabled',
+                    'drs disabled',
+                    'permission',
+                    'allowed',
+                    'document',
+                    'stewards',
+                    'penalty'
+                ]
+                
+                # Skip boring messages unless they're about important events
+                is_boring = any(keyword in message for keyword in boring_keywords)
+                is_important = (
+                    'safety car' in message or
+                    'red flag' in message or
+                    'chequered' in message or 'checkered' in message or
+                    'session started' in message or
+                    'green flag' in message or
+                    'incident' in message or
+                    'crash' in message or
+                    'collision' in message
+                )
+                
+                if is_boring and not is_important:
+                    continue  # Skip this boring message
+                
+                # Detect flags (only important ones)
                 if 'flag' in message or 'flag' in category:
                     flag_type = 'yellow'
                     if 'red' in message:
@@ -528,9 +569,11 @@ class EventParser:
                     elif 'green' in message:
                         flag_type = 'green'
                     elif 'blue' in message:
-                        flag_type = 'blue'
+                        continue  # Skip blue flags (not interesting for commentary)
                     elif 'chequered' in message or 'checkered' in message:
                         flag_type = 'chequered'
+                    elif 'yellow' not in message:
+                        continue  # Skip other flag types
                     
                     # Check if this is the race start (first green flag after grid)
                     is_race_start = False
@@ -555,7 +598,7 @@ class EventParser:
                     logger.info(f"Detected flag: {flag_type}")
                 
                 # Detect race start from "SESSION STARTED" message
-                if 'session started' in message and not self._race_started and self._starting_grid_announced:
+                elif 'session started' in message and not self._race_started and self._starting_grid_announced:
                     self._race_started = True
                     event = RaceEvent(
                         event_type=EventType.FLAG,
@@ -572,7 +615,7 @@ class EventParser:
                     logger.info("Detected race start from SESSION STARTED message!")
                 
                 # Detect safety car
-                if 'safety car' in message or 'sc' in category:
+                elif 'safety car' in message or 'sc' in category:
                     status = 'deployed'
                     if 'in' in message:
                         status = 'in'
@@ -591,19 +634,20 @@ class EventParser:
                     events.append(event)
                     logger.info(f"Detected safety car: {status}")
                 
-                # Detect incidents
-                if 'incident' in message or 'crash' in message or 'collision' in message:
-                    event = RaceEvent(
-                        event_type=EventType.INCIDENT,
-                        timestamp=datetime.now(),
-                        data={
-                            'description': entry.get('message', ''),
-                            'drivers_involved': [],  # Would need more parsing
-                            'lap_number': lap_number
-                        }
-                    )
-                    events.append(event)
-                    logger.info(f"Detected incident: {entry.get('message', '')}")
+                # Skip incidents for now - they flood the queue at race start
+                # TODO: Re-enable incidents with better filtering later
+                # elif 'incident' in message or 'crash' in message or 'collision' in message:
+                #     event = RaceEvent(
+                #         event_type=EventType.INCIDENT,
+                #         timestamp=datetime.now(),
+                #         data={
+                #             'description': entry.get('message', ''),
+                #             'drivers_involved': [],  # Would need more parsing
+                #             'lap_number': lap_number
+                #         }
+                #     )
+                #     events.append(event)
+                #     logger.info(f"Detected incident: {entry.get('message', '')}")
                     
         except Exception as e:
             logger.error(f"[DataIngestion] Error parsing race control data: {e}", exc_info=True)
@@ -660,14 +704,22 @@ class EventParser:
         """
         events = []
         
+        logger.debug(f"[EventParser] parse_overtakes_data called with {len(data) if data else 0} records")
+        
         if not data:
+            logger.debug("[EventParser] No overtake data to parse")
             return events
         
+        logger.info(f"[EventParser] Parsing {len(data)} overtake records")
+        
         try:
             for entry in data:
-                overtaking_driver_num = entry.get('driver_number')
+                overtaking_driver_num = entry.get('overtaking_driver_number')
                 overtaken_driver_num = entry.get('overtaken_driver_number')
                 lap_number = entry.get('lap_number', 1)
+                position = entry.get('position')  # New position after overtake
+                
+                logger.debug(f"[EventParser] Processing overtake: {overtaking_driver_num} -> {overtaken_driver_num}")
                 
                 if overtaking_driver_num and overtaken_driver_num:
                     # Get driver names
@@ -682,15 +734,19 @@ class EventParser:
                             'overtaken_driver': overtaken_driver,
                             'overtaking_driver_number': str(overtaking_driver_num),
                             'overtaken_driver_number': str(overtaken_driver_num),
+                            'new_position': position,  # Add the position
                             'lap_number': lap_number
                         }
                     )
                     events.append(event)
-                    logger.info(f"Detected overtake: {overtaking_driver} overtakes {overtaken_driver} on lap {lap_number}")
+                    logger.debug(f"Parsed overtake: {overtaking_driver} overtakes {overtaken_driver} for P{position} on lap {lap_number}")
+                else:
+                    logger.warning(f"[EventParser] Skipping overtake with missing driver numbers: {entry}")
                     
         except Exception as e:
             logger.error(f"[DataIngestion] Error parsing overtakes data: {e}", exc_info=True)
         
+        logger.info(f"[EventParser] Created {len(events)} overtake events")
         return events
     
     def parse_starting_grid_data(self, data: List[Dict]) -> List[RaceEvent]:
@@ -879,6 +935,13 @@ class DataIngestionModule:
         
         self._running = True
         logger.info(f"Data ingestion module started in REPLAY mode at {self.config.replay_speed}x speed")
+        
+        # Wait for replay to complete (keep thread alive)
+        # The replay controller runs in its own thread, so we need to wait for it
+        while self._running and self._replay_controller and not self._replay_controller.is_stopped():
+            time.sleep(0.1)
+        
+        logger.info("Replay mode completed")
         return True
     
     def _replay_event_callback(self, endpoint: str, data: Dict) -> None:
@@ -910,9 +973,16 @@ class DataIngestionModule:
                 logger.warning(f"Unknown endpoint in replay: {endpoint}")
                 return
             
+            # Debug: log endpoint being processed
+            logger.debug(f"[DataIngestion] Processing {endpoint} event")
+            
             # Parse events (parser expects a list)
             events = parser_func([data])
             
+            # Debug: log how many events were generated
+            if events:
+                logger.debug(f"[DataIngestion] Generated {len(events)} events from {endpoint}")
+            
             # Emit events to queue
             for event in events:
                 self.event_queue.enqueue(event)

reachy_f1_commentator/src/event_queue.py

@@ -139,9 +139,9 @@ class PriorityEventQueue:
         Assign priority based on event type.
         
         Priority assignment logic:
-        - CRITICAL: Starting grid, race start, incidents, safety car, lead changes
-        - HIGH: Overtakes, pit stops
-        - MEDIUM: Fastest laps
+        - CRITICAL: Starting grid, race start, overtakes, pit stops, incidents, safety car, lead changes
+        - HIGH: Fastest laps
+        - MEDIUM: Race control messages (flags, etc.)
         - LOW: Routine position updates
         
         Args:
@@ -154,11 +154,22 @@ class PriorityEventQueue:
         if event.data.get('is_starting_grid') or event.data.get('is_race_start'):
             return EventPriority.CRITICAL
         
-        if event.event_type in [EventType.INCIDENT, EventType.SAFETY_CAR, EventType.LEAD_CHANGE]:
+        # Overtakes and pit stops are the most interesting events - make them CRITICAL
+        if event.event_type in [EventType.OVERTAKE, EventType.PIT_STOP]:
             return EventPriority.CRITICAL
-        elif event.event_type in [EventType.OVERTAKE, EventType.PIT_STOP]:
-            return EventPriority.HIGH
+        
+        # Safety car and lead changes also CRITICAL (incidents disabled for now)
+        if event.event_type in [EventType.SAFETY_CAR, EventType.LEAD_CHANGE]:
+            return EventPriority.CRITICAL
+        
+        # Fastest laps are interesting but less critical
         elif event.event_type == EventType.FASTEST_LAP:
+            return EventPriority.HIGH
+        
+        # Race control messages (flags, etc.) are medium priority
+        elif event.event_type == EventType.FLAG:
             return EventPriority.MEDIUM
+        
+        # Everything else is low priority
         else:
             return EventPriority.LOW

reachy_f1_commentator/src/replay_mode.py

@@ -50,6 +50,10 @@ class HistoricalDataLoader:
         
         # Setup session (no auth needed for historical data)
         self.session = requests.Session()
+        
+        # Rate limiting: track last request time
+        self._last_request_time = 0
+        self._min_request_interval = 0.5  # Minimum 0.5 seconds between requests
     
     def find_session_key(self, year: int, country_name: str, session_name: str = "Race") -> Optional[int]:
         """
@@ -171,6 +175,7 @@ class HistoricalDataLoader:
     def _fetch_endpoint(self, endpoint: str, session_key: int) -> List[Dict]:
         """
         Fetch data from a specific endpoint for a session.
+        Includes rate limiting to avoid 429 errors.
         
         Args:
             endpoint: API endpoint path (e.g., '/position')
@@ -179,11 +184,20 @@ class HistoricalDataLoader:
         Returns:
             List of data dictionaries
         """
+        # Rate limiting: ensure minimum interval between requests
+        current_time = time.time()
+        time_since_last_request = current_time - self._last_request_time
+        if time_since_last_request < self._min_request_interval:
+            sleep_time = self._min_request_interval - time_since_last_request
+            logger.debug(f"Rate limiting: sleeping {sleep_time:.2f}s before request")
+            time.sleep(sleep_time)
+        
         url = f"{self.base_url}{endpoint}"
         params = {'session_key': session_key}
         
         try:
             response = self.session.get(url, params=params, timeout=10)  # Increased timeout for large datasets
+            self._last_request_time = time.time()  # Update last request time
             response.raise_for_status()
             
             data = response.json()
@@ -197,6 +211,23 @@ class HistoricalDataLoader:
                 logger.warning(f"Unexpected data type from {endpoint}: {type(data)}")
                 return []
                 
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 429:
+                logger.warning(f"Rate limit hit for {endpoint}, waiting 2 seconds and retrying...")
+                time.sleep(2)
+                # Retry once
+                try:
+                    response = self.session.get(url, params=params, timeout=10)
+                    self._last_request_time = time.time()
+                    response.raise_for_status()
+                    data = response.json()
+                    return data if isinstance(data, list) else [data] if isinstance(data, dict) else []
+                except Exception as retry_error:
+                    logger.error(f"[ReplayMode] Retry failed for {endpoint}: {retry_error}")
+                    return []
+            else:
+                logger.error(f"[ReplayMode] Failed to fetch {endpoint} for session {session_key}: {e}", exc_info=True)
+                return []
         except requests.exceptions.RequestException as e:
             logger.error(f"[ReplayMode] Failed to fetch {endpoint} for session {session_key}: {e}", exc_info=True)
             return []
@@ -306,8 +337,12 @@ class ReplayController:
             List of events with 'endpoint', 'data', and 'timestamp' fields
         """
         timeline = []
+        endpoint_counts = {}
         
         for endpoint, data_list in self.race_data.items():
+            count = len(data_list)
+            endpoint_counts[endpoint] = count
+            
             for data in data_list:
                 # Extract timestamp
                 timestamp = self._extract_timestamp(data)
@@ -322,6 +357,7 @@ class ReplayController:
         timeline.sort(key=lambda x: x['timestamp'])
         
         logger.info(f"Built timeline with {len(timeline)} events")
+        logger.info(f"Endpoint breakdown: {endpoint_counts}")
         return timeline
     
     def _extract_timestamp(self, data: Dict) -> datetime:
@@ -420,6 +456,8 @@ class ReplayController:
         
         Validates: Requirement 9.4
         """
+        logger.info(f"[ReplayMode] stop() called at event {self._current_index}, stopped was {self._stopped}")
+        
         self._stopped = True
         self._paused = False
         
@@ -495,61 +533,92 @@ class ReplayController:
         
         Validates: Requirements 9.2, 9.4
         """
-        if not self._timeline:
-            logger.warning("No events in timeline to replay")
-            return
-        
-        # Get the first event's timestamp as reference
-        first_timestamp = self._timeline[0]['timestamp']
-        last_event_timestamp = first_timestamp
-        
-        # Track cumulative race time (excluding large gaps if enabled)
-        cumulative_race_time = 0.0
-        
-        while self._current_index < len(self._timeline) and not self._stopped:
-            # Handle pause
-            while self._paused and not self._stopped:
-                time.sleep(0.1)
-            
-            if self._stopped:
-                break
-            
-            # Get current event
-            event = self._timeline[self._current_index]
-            event_timestamp = event['timestamp']
-            
-            # Calculate time since last event
-            time_since_last = (event_timestamp - last_event_timestamp).total_seconds()
-            
-            # ALWAYS skip absurdly large gaps (> 600 seconds = 10 minutes)
-            # These are data artifacts, not actual race time
-            if time_since_last > 600.0:
-                logger.info(f"Skipping absurd time gap of {time_since_last:.1f}s at event {self._current_index} (data artifact)")
-                time_since_last = 0.0
-            # Skip moderate gaps (> 60 seconds) if skip_large_gaps is enabled
-            elif self.skip_large_gaps and time_since_last > 60.0:
-                logger.info(f"Skipping large time gap of {time_since_last:.1f}s at event {self._current_index}")
-                time_since_last = 0.0
+        try:
+            if not self._timeline:
+                logger.warning("No events in timeline to replay")
+                return
             
-            # Add to cumulative race time
-            cumulative_race_time += time_since_last
+            logger.info(f"[ReplayMode] Starting playback loop with {len(self._timeline)} events")
             
-            # Time since playback started (adjusted for speed and pauses)
-            playback_time_elapsed = (time.time() - self._start_time - self._total_paused_duration) * self.playback_speed
+            # Get the first event's timestamp as reference
+            first_timestamp = self._timeline[0]['timestamp']
+            last_event_timestamp = first_timestamp
             
-            # Wait if we're ahead of schedule
-            wait_time = cumulative_race_time - playback_time_elapsed
-            if wait_time > 0:
-                time.sleep(wait_time / self.playback_speed)
+            # Track cumulative race time (excluding large gaps if enabled)
+            cumulative_race_time = 0.0
             
-            # Emit event
-            if self._event_callback and not self._stopped:
-                try:
-                    self._event_callback(event['endpoint'], event['data'])
-                except Exception as e:
-                    logger.error(f"[ReplayMode] Error in event callback: {e}", exc_info=True)
+            while self._current_index < len(self._timeline) and not self._stopped:
+                # Debug: log loop condition
+                if self._current_index == 42:
+                    logger.info(f"[ReplayMode] At event 42: current_index={self._current_index}, timeline_len={len(self._timeline)}, stopped={self._stopped}")
+                
+                # Handle pause
+                while self._paused and not self._stopped:
+                    time.sleep(0.1)
+                
+                if self._stopped:
+                    logger.info(f"[ReplayMode] Stopped at event {self._current_index}/{len(self._timeline)}")
+                    break
+                
+                # Get current event
+                event = self._timeline[self._current_index]
+                event_timestamp = event['timestamp']
+                
+                # Calculate time since last event
+                time_since_last = (event_timestamp - last_event_timestamp).total_seconds()
+                
+                # ALWAYS skip absurdly large gaps (> 600 seconds = 10 minutes)
+                # These are data artifacts, not actual race time
+                if time_since_last > 600.0:
+                    logger.info(f"Skipping absurd time gap of {time_since_last:.1f}s at event {self._current_index} (data artifact)")
+                    time_since_last = 0.0
+                # Handle pre-race to race transition (starting grid -> race start)
+                # Skip ALL gaps > 10 seconds in the first 100 events (pre-race phase)
+                # This handles the gap from grid formation to lights out without long waits
+                elif time_since_last > 10.0 and self._current_index < 100:
+                    logger.info(f"Skipping pre-race time gap of {time_since_last:.1f}s at event {self._current_index} (grid -> race start)")
+                    time_since_last = 0.0
+                # Skip moderate gaps (> 60 seconds) if skip_large_gaps is enabled (after first 100 events)
+                elif self.skip_large_gaps and time_since_last > 60.0 and self._current_index >= 100:
+                    logger.info(f"Skipping large time gap of {time_since_last:.1f}s at event {self._current_index}")
+                    time_since_last = 0.0
+                
+                # Add to cumulative race time
+                cumulative_race_time += time_since_last
+                
+                # Time since playback started (adjusted for speed and pauses)
+                playback_time_elapsed = (time.time() - self._start_time - self._total_paused_duration) * self.playback_speed
+                
+                # Wait if we're ahead of schedule
+                wait_time = cumulative_race_time - playback_time_elapsed
+                if wait_time > 0:
+                    # Log long waits
+                    if wait_time > 10.0:
+                        logger.info(f"[ReplayMode] Long wait: {wait_time:.1f}s at event {self._current_index}")
+                    time.sleep(wait_time / self.playback_speed)
+                elif wait_time < -60.0:
+                    # We're way behind schedule - log it
+                    logger.warning(f"[ReplayMode] Behind schedule by {-wait_time:.1f}s at event {self._current_index}")
+                
+                # Emit event
+                if self._event_callback and not self._stopped:
+                    try:
+                        self._event_callback(event['endpoint'], event['data'])
+                    except Exception as e:
+                        logger.error(f"[ReplayMode] Error in event callback: {e}", exc_info=True)
+                
+                last_event_timestamp = event_timestamp
+                self._current_index += 1
+                
+                # Log progress every 100 events
+                if self._current_index % 100 == 0:
+                    logger.info(f"[ReplayMode] Progress: {self._current_index}/{len(self._timeline)} events processed")
             
-            last_event_timestamp = event_timestamp
-            self._current_index += 1
+            # Loop exited - log why
+            logger.info(f"[ReplayMode] Loop exited: current_index={self._current_index}, timeline_len={len(self._timeline)}, stopped={self._stopped}")
         
-        logger.info("Replay playback completed")
+            logger.info(f"[ReplayMode] Playback loop completed: {self._current_index}/{len(self._timeline)} events processed")
+            logger.info("Replay playback completed")
+            
+        except Exception as e:
+            logger.error(f"[ReplayMode] Exception in playback loop at event {self._current_index}: {e}", exc_info=True)

reachy_f1_commentator/static/index.html

@@ -109,7 +109,7 @@
 
         <div class="info-panel">
             <h3>Full Historical Race Mode</h3>
-            <p>Replay any F1 race from 2018-2024 with:</p>
+            <p>Replay any F1 race from 2023-2025 with:</p>
             <ul>
                 <li>Real race data from OpenF1 API</li>
                 <li>Configurable playback speed</li>

test_full_race_commentary.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""
+Test script to simulate full race commentary without TTS.
+
+This script runs through a complete race replay and generates all commentary,
+simulating TTS delays to see the actual event processing order and timing.
+"""
+
+import logging
+import time
+import sys
+import os
+from datetime import datetime
+from collections import defaultdict
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+logger = logging.getLogger(__name__)
+
+# Suppress verbose logs from other modules
+logging.getLogger('reachy_f1_commentator.src.replay_mode').setLevel(logging.WARNING)
+logging.getLogger('reachy_f1_commentator.src.data_ingestion').setLevel(logging.INFO)
+
+
+def main():
+    """Run full race commentary test."""
+    # Direct imports to avoid main.py
+    from reachy_f1_commentator.src.replay_mode import HistoricalDataLoader, ReplayController
+    from reachy_f1_commentator.src.data_ingestion import DataIngestionModule
+    from reachy_f1_commentator.src.commentary_generator import CommentaryGenerator
+    from reachy_f1_commentator.src.race_state_tracker import RaceStateTracker
+    from reachy_f1_commentator.src.config import Config
+    from reachy_f1_commentator.src.event_queue import PriorityEventQueue
+    from reachy_f1_commentator.src.models import EventType
+    
+    # Configuration
+    SESSION_KEY = 9998  # Session with complete data
+    PLAYBACK_SPEED = 10  # 10x speed
+    SIMULATE_TTS_DELAY = True  # Simulate TTS taking time
+    TTS_DELAY_PER_CHAR = 0.015  # ~3.7 seconds for 250 chars
+    MAX_EVENTS = 100  # Limit events for testing (set to None for full race)
+    
+    logger.info("=" * 80)
+    logger.info("FULL RACE COMMENTARY TEST")
+    logger.info("=" * 80)
+    logger.info(f"Session: {SESSION_KEY}")
+    logger.info(f"Playback Speed: {PLAYBACK_SPEED}x")
+    logger.info(f"Simulate TTS: {SIMULATE_TTS_DELAY}")
+    logger.info(f"Max Events: {MAX_EVENTS if MAX_EVENTS else 'unlimited'}")
+    logger.info("=" * 80)
+    
+    # Initialize components
+    logger.info("\n📥 Loading race data...")
+    
+    # Create historical data loader
+    data_loader = HistoricalDataLoader(
+        api_key="",
+        base_url="https://api.openf1.org/v1",
+        cache_dir=".test_cache"
+    )
+    
+    # Load race data
+    race_data = data_loader.load_race(SESSION_KEY)
+    
+    if not race_data:
+        logger.error("❌ Failed to load race data")
+        return
+    
+    # Get metadata
+    total_records = sum(len(v) for v in race_data.values())
+    logger.info(f"✅ Race loaded:")
+    logger.info(f"   - Total records: {total_records}")
+    logger.info(f"   - Drivers: {len(race_data.get('drivers', []))}")
+    logger.info(f"   - Position updates: {len(race_data.get('position', []))}")
+    logger.info(f"   - Pit stops: {len(race_data.get('pit', []))}")
+    logger.info(f"   - Overtakes: {len(race_data.get('overtakes', []))}")
+    
+    # Initialize config and components
+    config = Config()
+    config.replay_mode = True
+    config.replay_race_id = SESSION_KEY
+    config.replay_speed = PLAYBACK_SPEED
+    config.enhanced_mode = False
+    
+    event_queue = PriorityEventQueue(max_size=100)
+    state_tracker = RaceStateTracker()
+    commentary_generator = CommentaryGenerator(config, state_tracker)
+    
+    # Create data ingestion module
+    data_ingestion = DataIngestionModule(config=config, event_queue=event_queue)
+    
+    # Statistics tracking
+    event_counts = defaultdict(int)
+    commentary_counts = defaultdict(int)
+    total_events = 0
+    total_commentary = 0
+    total_tts_time = 0.0
+    start_time = time.time()
+    
+    logger.info("\n🏁 Starting race playback...\n")
+    
+    # Start data ingestion in background thread
+    import threading
+    ingestion_thread = threading.Thread(target=data_ingestion.start, daemon=True)
+    ingestion_thread.start()
+    
+    # Give it a moment to start
+    time.sleep(0.5)
+    
+    # Process events from queue
+    try:
+        no_event_count = 0
+        max_no_event_iterations = 50
+        
+        while True:
+            # Get event from queue
+            event = event_queue.dequeue()
+            
+            if event is not None:
+                no_event_count = 0
+                total_events += 1
+                event_counts[event.event_type.value] += 1
+                
+                # Check max events limit
+                if MAX_EVENTS and total_events > MAX_EVENTS:
+                    logger.info(f"\n⚠️  Reached max events limit ({MAX_EVENTS}), stopping...")
+                    break
+                
+                # Get lap number
+                lap_number = event.data.get('lap_number', 0)
+                
+                # Generate commentary
+                try:
+                    commentary = commentary_generator.generate(event)
+                    
+                    # Skip empty commentary
+                    if not commentary or not commentary.strip():
+                        continue
+                    
+                    total_commentary += 1
+                    commentary_counts[event.event_type.value] += 1
+                    
+                    # Calculate TTS delay
+                    tts_delay = 0.0
+                    if SIMULATE_TTS_DELAY:
+                        tts_delay = len(commentary) * TTS_DELAY_PER_CHAR
+                        total_tts_time += tts_delay
+                    
+                    # Log commentary with timing info
+                    logger.info(
+                        f"[Lap {lap_number:2d}] [{event.event_type.value:15s}] "
+                        f"{commentary[:80]}{'...' if len(commentary) > 80 else ''}"
+                    )
+                    if SIMULATE_TTS_DELAY:
+                        logger.info(f"           💬 TTS delay: {tts_delay:.2f}s")
+                    
+                    # Simulate TTS delay
+                    if SIMULATE_TTS_DELAY:
+                        time.sleep(tts_delay)
+                    
+                    # Add pacing delay (same as in main.py)
+                    pacing_delay = 1.0 / PLAYBACK_SPEED
+                    time.sleep(pacing_delay)
+                    
+                except Exception as e:
+                    logger.error(f"❌ Error generating commentary: {e}", exc_info=True)
+            
+            else:
+                # No event available
+                no_event_count += 1
+                
+                # Check if thread is still alive
+                if not ingestion_thread.is_alive():
+                    # Thread stopped, check if there are any remaining events
+                    remaining_event = event_queue.dequeue()
+                    if remaining_event is None:
+                        logger.info("\n✅ Ingestion thread stopped and queue is empty")
+                        break
+                    else:
+                        # Process remaining event
+                        event = remaining_event
+                        no_event_count = 0
+                        continue
+                elif no_event_count >= max_no_event_iterations:
+                    logger.warning(f"\n⚠️  No events for {max_no_event_iterations} iterations, stopping")
+                    break
+                else:
+                    # Wait a bit before checking again
+                    time.sleep(0.1)
+    
+    except KeyboardInterrupt:
+        logger.info("\n⚠️  Interrupted by user")
+    finally:
+        # Stop data ingestion
+        data_ingestion.stop()
+    
+    # Print statistics
+    elapsed_time = time.time() - start_time
+    
+    logger.info("\n" + "=" * 80)
+    logger.info("RACE COMMENTARY STATISTICS")
+    logger.info("=" * 80)
+    
+    logger.info(f"\n📊 Event Statistics:")
+    logger.info(f"   Total events processed: {total_events}")
+    for event_type, count in sorted(event_counts.items(), key=lambda x: x[1], reverse=True):
+        logger.info(f"   - {event_type:20s}: {count:4d}")
+    
+    logger.info(f"\n🎙️  Commentary Statistics:")
+    logger.info(f"   Total commentary pieces: {total_commentary}")
+    for event_type, count in sorted(commentary_counts.items(), key=lambda x: x[1], reverse=True):
+        logger.info(f"   - {event_type:20s}: {count:4d}")
+    
+    logger.info(f"\n⏱️  Timing Statistics:")
+    logger.info(f"   Elapsed time: {elapsed_time:.1f}s")
+    logger.info(f"   Simulated TTS time: {total_tts_time:.1f}s")
+    logger.info(f"   Average TTS per commentary: {total_tts_time/total_commentary if total_commentary > 0 else 0:.2f}s")
+    
+    # Calculate what percentage of events got commentary
+    if total_events > 0:
+        commentary_rate = (total_commentary / total_events) * 100
+        logger.info(f"\n📈 Commentary Rate: {commentary_rate:.1f}% of events generated commentary")
+    
+    logger.info("\n" + "=" * 80)
+    
+    # Identify missing event types
+    events_without_commentary = set(event_counts.keys()) - set(commentary_counts.keys())
+    if events_without_commentary:
+        logger.info("\n⚠️  Event types that generated NO commentary:")
+        for event_type in events_without_commentary:
+            logger.info(f"   - {event_type} ({event_counts[event_type]} events)")
+    
+    logger.info("\n✅ Test complete!")
+
+
+if __name__ == "__main__":
+    main()

test_race_events.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Simple test to see what events are being generated from a race replay.
+"""
+
+import sys
+import os
+import logging
+import time
+import threading
+from collections import defaultdict
+
+# Setup logging
+logging.basicConfig(
+    level=logging.DEBUG,  # Changed to DEBUG to see more details
+    format='%(message)s'
+)
+
+logger = logging.getLogger(__name__)
+
+# Suppress verbose logs
+logging.getLogger('urllib3').setLevel(logging.WARNING)
+logging.getLogger('reachy_f1_commentator.src.replay_mode').setLevel(logging.INFO)  # Show replay logs
+
+# Direct imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from reachy_f1_commentator.src.replay_mode import HistoricalDataLoader
+from reachy_f1_commentator.src.data_ingestion import DataIngestionModule
+from reachy_f1_commentator.src.config import Config
+from reachy_f1_commentator.src.event_queue import PriorityEventQueue
+
+# Configuration
+SESSION_KEY = 9998
+PLAYBACK_SPEED = 10
+MAX_EVENTS = 500  # Increased to see more events
+
+logger.info("=" * 80)
+logger.info(f"RACE EVENT ANALYSIS - Session {SESSION_KEY} at {PLAYBACK_SPEED}x speed")
+logger.info("=" * 80)
+
+# Load race data
+logger.info("\nLoading race data...")
+data_loader = HistoricalDataLoader(
+    api_key="",
+    base_url="https://api.openf1.org/v1",
+    cache_dir=".test_cache"
+)
+
+race_data = data_loader.load_race(SESSION_KEY)
+
+if not race_data:
+    logger.error("Failed to load race data")
+    sys.exit(1)
+
+# Print data summary
+logger.info(f"\nRace Data Summary:")
+logger.info(f"  Drivers: {len(race_data.get('drivers', []))}")
+logger.info(f"  Starting Grid: {len(race_data.get('starting_grid', []))}")
+logger.info(f"  Position Updates: {len(race_data.get('position', []))}")
+logger.info(f"  Pit Stops: {len(race_data.get('pit', []))}")
+logger.info(f"  Overtakes: {len(race_data.get('overtakes', []))}")
+logger.info(f"  Laps: {len(race_data.get('laps', []))}")
+logger.info(f"  Race Control: {len(race_data.get('race_control', []))}")
+
+# Setup replay
+config = Config()
+config.replay_mode = True
+config.replay_race_id = SESSION_KEY
+config.replay_speed = PLAYBACK_SPEED
+
+event_queue = PriorityEventQueue(max_size=100)
+data_ingestion = DataIngestionModule(config=config, event_queue=event_queue)
+
+# Start ingestion
+logger.info(f"\nStarting replay at {PLAYBACK_SPEED}x speed...")
+logger.info("=" * 80)
+
+ingestion_thread = threading.Thread(target=data_ingestion.start, daemon=True)
+ingestion_thread.start()
+
+time.sleep(0.5)
+
+# Track events
+event_counts = defaultdict(int)
+event_samples = defaultdict(list)
+total_events = 0
+
+try:
+    no_event_count = 0
+    
+    while total_events < MAX_EVENTS:
+        event = event_queue.dequeue()
+        
+        if event is not None:
+            no_event_count = 0
+            total_events += 1
+            event_type = event.event_type.value
+            event_counts[event_type] += 1
+            
+            # Store first 3 samples of each type
+            if len(event_samples[event_type]) < 3:
+                event_samples[event_type].append(event.data)
+            
+            # Print event
+            lap = event.data.get('lap_number', 0)
+            logger.info(f"[{total_events:3d}] [Lap {lap:2d}] {event_type:20s} - {str(event.data)[:80]}")
+            
+        else:
+            no_event_count += 1
+            if not ingestion_thread.is_alive() and event_queue.size() == 0:
+                logger.info("\nIngestion complete, queue empty")
+                break
+            elif no_event_count >= 50:
+                logger.info(f"\nNo events for 5 seconds, stopping")
+                break
+            time.sleep(0.1)
+
+except KeyboardInterrupt:
+    logger.info("\nInterrupted by user")
+
+# Stop ingestion
+data_ingestion.stop()
+
+# Print summary
+logger.info("\n" + "=" * 80)
+logger.info("EVENT SUMMARY")
+logger.info("=" * 80)
+logger.info(f"\nTotal events processed: {total_events}")
+logger.info(f"\nEvent counts:")
+for event_type, count in sorted(event_counts.items(), key=lambda x: x[1], reverse=True):
+    logger.info(f"  {event_type:20s}: {count:4d}")
+
+logger.info(f"\nEvent samples (first 3 of each type):")
+for event_type, samples in sorted(event_samples.items()):
+    logger.info(f"\n  {event_type}:")
+    for i, sample in enumerate(samples, 1):
+        logger.info(f"    {i}. {sample}")
+
+logger.info("\n" + "=" * 80)