restoring missing clock reset detection functions

src/config/session.py

@@ -255,7 +255,7 @@ def _save_timeout_config(config: SessionConfig, output_dir: Path, basename: str)
 def save_session_config(
     config: SessionConfig,
     output_dir: Path,
-    selected_frame: Tuple[float, np.ndarray] = None,
+    selected_frame: Tuple[float, np.ndarray] | None = None,
 ) -> Tuple[str, str]:
     """
     Save session configuration and generate template image.

src/detection/models.py

@@ -5,7 +5,7 @@ These models represent the results of detecting various elements in video frames
 scorebug presence and timeout indicators.
 """
 
-from typing import Optional, Tuple, List
+from typing import Any, Optional, Tuple, List
 
 from pydantic import BaseModel, Field
 
@@ -27,7 +27,7 @@ class TimeoutRegionConfig(BaseModel):
     team_name: str = Field(..., description="'home' or 'away'")
     bbox: Tuple[int, int, int, int] = Field(..., description="x, y, width, height for the 3-oval group")
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, object]:
         """Convert to dictionary for JSON serialization."""
         return {
             "team_name": self.team_name,
@@ -35,7 +35,7 @@ class TimeoutRegionConfig(BaseModel):
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> "TimeoutRegionConfig":
+    def from_dict(cls, data: dict[str, Any]) -> "TimeoutRegionConfig":
         """Create from dictionary."""
         bbox = (data["bbox"]["x"], data["bbox"]["y"], data["bbox"]["width"], data["bbox"]["height"])
         return cls(team_name=data["team_name"], bbox=bbox)

src/pipeline/orchestrator.py

@@ -13,9 +13,10 @@ import logging
 from pathlib import Path
 from typing import Any, Dict
 
-from config.session import SessionConfig, MIN_PLAY_DURATION
+from config import SessionConfig, MIN_PLAY_DURATION
 from detection import DetectTimeouts
-from pipeline.play_detector import DetectionConfig, PlayDetector, format_detection_result_dict
+from pipeline import DetectionConfig
+from pipeline.play_detector import PlayDetector, format_detection_result_dict
 
 logger = logging.getLogger(__name__)
 
@@ -165,7 +166,7 @@ def print_results_summary(
     video_basename: str,
     generate_individual: bool,
     expected_plays: int = 12,
-):
+) -> None:
     """
     Print the final results summary.
 

src/pipeline/parallel.py

@@ -175,13 +175,14 @@ def _read_video_frames(cap: Any, start_frame: int, end_frame: int, frame_skip: i
 
     return frames, io_time
 
+
 # pylint: disable=too-many-locals
 def _process_chunk(
     chunk_id: int,
     config: ParallelProcessingConfig,
     chunk_start: float,
     chunk_end: float,
-    progress_dict: Optional[Dict] = None,
+    progress_dict: Optional[Dict[int, Any]] = None,
 ) -> ChunkResult:
     """
     Process a single video chunk using OpenCV.
@@ -309,7 +310,7 @@ def _calculate_chunk_boundaries(start_time: float, end_time: float, num_workers:
     return chunks
 
 
-def _create_progress_monitor(progress_dict: Dict, num_workers: int) -> Tuple[threading.Thread, threading.Event]:
+def _create_progress_monitor(progress_dict: Dict[int, Any], num_workers: int) -> Tuple[threading.Thread, threading.Event]:
     """
     Create a progress monitoring thread.
 
@@ -322,7 +323,7 @@ def _create_progress_monitor(progress_dict: Dict, num_workers: int) -> Tuple[thr
     """
     stop_monitor = threading.Event()
 
-    def monitor_progress():
+    def monitor_progress() -> None:
         """Monitor and display progress from workers."""
         while not stop_monitor.is_set():
             _display_progress(progress_dict, num_workers)
@@ -332,7 +333,7 @@ def _create_progress_monitor(progress_dict: Dict, num_workers: int) -> Tuple[thr
     return monitor_thread, stop_monitor
 
 
-def _display_progress(progress_dict: Dict, num_workers: int) -> None:
+def _display_progress(progress_dict: Dict[int, Any], num_workers: int) -> None:
     """
     Build and display current progress string.
 
@@ -385,8 +386,8 @@ def _submit_chunk_jobs(
     executor: ProcessPoolExecutor,
     chunks: List[Tuple[int, float, float]],
     config: ParallelProcessingConfig,
-    progress_dict: Dict,
-) -> Dict[Future, int]:
+    progress_dict: Dict[int, Any],
+) -> Dict[Future[ChunkResult], int]:
     """
     Submit all chunk processing jobs to the executor.
 
@@ -413,7 +414,7 @@ def _submit_chunk_jobs(
     return futures
 
 
-def _collect_chunk_results(futures: Dict[Future, int]) -> Dict[int, Optional[ChunkResult]]:
+def _collect_chunk_results(futures: Dict[Future[ChunkResult], int]) -> Dict[int, Optional[ChunkResult]]:
     """
     Collect results from all chunk futures as they complete.
 

src/pipeline/play_detector.py

@@ -449,17 +449,21 @@ class PlayDetector:
         context: VideoContext,
         stats: Dict[str, Any],
         timing: Dict[str, float],
+        frame_data: List[Dict[str, Any]],
     ) -> DetectionResult:
         """
-        Finalize detection: apply filtering and build result.
+        Finalize detection: run post-hoc clock reset detection and build result.
 
-        Clock reset classification is now handled inline by TrackPlayState during
-        the streaming pass, so we just need to merge/filter and build the result.
+        Performs 3-class classification for 40→25 clock reset events:
+        - Class A (weird_clock): 25 counts down immediately → rejected
+        - Class B (timeout): Timeout indicator changed → tracked as timeout
+        - Class C (special): Neither A nor B → special play (punt/FG/XP)
 
         Args:
             context: Video context
             stats: Processing stats
             timing: Timing breakdown
+            frame_data: List of frame data dicts with clock values and timeout counts
 
         Returns:
             Final DetectionResult
@@ -467,23 +471,39 @@ class PlayDetector:
         # Log timing breakdown
         self._log_timing_breakdown(timing)
 
-        # Get plays from state machine (clock reset classification already done inline)
+        # Get plays from state machine (normal 40-second plays)
         state_machine_plays = self.state_machine.get_plays()
         play_stats = self.state_machine.get_stats()
 
-        # Log clock reset stats from state machine
-        clock_reset_stats = play_stats.get("clock_reset_events", {})
+        # Run post-hoc clock reset detection (40→25 transitions)
+        clock_reset_plays, clock_reset_stats = self._detect_clock_resets(frame_data)
         logger.info(
-            "Clock reset classification: %d total, %d weird (rejected), %d timeouts, %d special plays",
+            "Clock reset detection: %d total, %d weird (rejected), %d timeouts, %d special plays",
             clock_reset_stats.get("total", 0),
             clock_reset_stats.get("weird_clock", 0),
             clock_reset_stats.get("timeout", 0),
             clock_reset_stats.get("special", 0),
         )
 
-        # Use PlayMerger to deduplicate and apply quiet time filter
-        merger = PlayMerger()
-        plays = merger.merge(state_machine_plays)
+        # Merge clock reset stats into play stats
+        play_stats["clock_reset_events"] = clock_reset_stats
+
+        # Merge state machine plays with clock reset plays (handles deduplication)
+        plays = self._merge_plays(state_machine_plays, clock_reset_plays)
+
+        # Recalculate stats from merged plays
+        start_methods = {}
+        end_methods = {}
+        play_types = {}
+        for play in plays:
+            start_methods[play.start_method] = start_methods.get(play.start_method, 0) + 1
+            end_methods[play.end_method] = end_methods.get(play.end_method, 0) + 1
+            play_types[play.play_type] = play_types.get(play.play_type, 0) + 1
+
+        play_stats["total_plays"] = len(plays)
+        play_stats["start_methods"] = start_methods
+        play_stats["end_methods"] = end_methods
+        play_stats["play_types"] = play_types
 
         result = DetectionResult(
             video=Path(self.config.video_path).name,
@@ -518,6 +538,287 @@ class PlayDetector:
         logger.info("  TOTAL: %.2fs", total_time)
         logger.info("=" * 50)
 
+    # =========================================================================
+    # Clock Reset Detection (Post-hoc 40→25 analysis)
+    # =========================================================================
+
+    def _detect_clock_resets(self, frame_data: List[Dict[str, Any]]) -> Tuple[List[PlayEvent], Dict[str, int]]:
+        """
+        Detect and classify 40 -> 25 clock reset events.
+
+        Classification:
+        - Class A (weird_clock): 25 counts down immediately -> rejected
+        - Class B (timeout): Timeout indicator changed -> tracked as timeout
+        - Class C (special): Neither A nor B -> special play with extension
+
+        Args:
+            frame_data: List of frame data with clock values and timeout counts
+
+        Returns:
+            Tuple of (list of PlayEvent for valid clock resets, stats dict)
+        """
+        plays = []
+        stats = {"total": 0, "weird_clock": 0, "timeout": 0, "special": 0}
+
+        # Parameters
+        immediate_countdown_window = 2.0  # Seconds to check if 25 counts down
+        special_play_extension = 10.0  # Extension for Class C plays
+
+        prev_clock = None
+        saw_40_at = None
+
+        for i, frame in enumerate(frame_data):
+            clock_value = frame.get("clock_value")
+            timestamp = frame["timestamp"]
+
+            if clock_value is not None:
+                # Detect 40 -> 25 transition
+                if prev_clock == 40 and clock_value == 25:
+                    stats["total"] += 1
+
+                    # Check if 25 immediately counts down (Class A: weird clock)
+                    is_immediate_countdown = self._check_immediate_countdown(frame_data, i, immediate_countdown_window)
+
+                    # Check if timeout changed (Class B: team timeout)
+                    timeout_team = self._check_timeout_change(frame_data, i)
+
+                    if is_immediate_countdown:
+                        # Class A: Weird clock behavior - reject
+                        stats["weird_clock"] += 1
+                        logger.debug("Clock reset at %.1fs: weird_clock (25 counts down immediately)", timestamp)
+                    elif timeout_team:
+                        # Class B: Team timeout - record but mark as timeout
+                        stats["timeout"] += 1
+                        play_end = self._find_clock_reset_play_end(frame_data, i, max_duration=15.0)
+                        play = PlayEvent(
+                            play_number=0,
+                            start_time=timestamp,
+                            end_time=play_end,
+                            confidence=0.8,
+                            start_method=f"timeout_{timeout_team}",
+                            end_method="timeout_end",
+                            direct_end_time=play_end,
+                            start_clock_value=prev_clock,
+                            end_clock_value=25,
+                            play_type="timeout",
+                        )
+                        plays.append(play)
+                        logger.debug("Clock reset at %.1fs: timeout (%s team)", timestamp, timeout_team)
+                    else:
+                        # Class C: Special play (injury/punt/FG/XP)
+                        stats["special"] += 1
+                        play_end = self._find_clock_reset_play_end(frame_data, i, max_duration=special_play_extension)
+                        play_duration = play_end - timestamp
+                        end_method = "max_duration" if play_duration >= special_play_extension - 0.1 else "scorebug_disappeared"
+                        play = PlayEvent(
+                            play_number=0,
+                            start_time=timestamp,
+                            end_time=play_end,
+                            confidence=0.8,
+                            start_method="clock_reset_special",
+                            end_method=end_method,
+                            direct_end_time=play_end,
+                            start_clock_value=prev_clock,
+                            end_clock_value=25,
+                            play_type="special",
+                        )
+                        plays.append(play)
+                        logger.debug("Clock reset at %.1fs: special play (%.1fs duration)", timestamp, play_end - timestamp)
+
+                # Track when 40 first appeared
+                if clock_value == 40 and prev_clock != 40:
+                    saw_40_at = timestamp
+
+                prev_clock = clock_value
+
+        return plays, stats
+
+    def _check_immediate_countdown(self, frame_data: List[Dict[str, Any]], frame_idx: int, window: float) -> bool:
+        """Check if 25 immediately starts counting down (indicates weird clock behavior)."""
+        reset_timestamp = frame_data[frame_idx]["timestamp"]
+
+        for j in range(frame_idx + 1, len(frame_data)):
+            frame = frame_data[j]
+            elapsed = frame["timestamp"] - reset_timestamp
+            if elapsed > window:
+                break
+            clock_value = frame.get("clock_value")
+            if clock_value is not None and clock_value < 25:
+                return True  # 25 counted down - weird clock
+
+        return False
+
+    def _check_timeout_change(self, frame_data: List[Dict[str, Any]], frame_idx: int) -> Optional[str]:
+        """Check if a timeout indicator changed around the reset."""
+        # Get timeout counts before reset
+        before_home = None
+        before_away = None
+
+        for j in range(frame_idx - 1, max(0, frame_idx - 20), -1):
+            frame = frame_data[j]
+            if frame.get("home_timeouts") is not None:
+                before_home = frame.get("home_timeouts", 3)
+                before_away = frame.get("away_timeouts", 3)
+                break
+
+        if before_home is None:
+            return None
+
+        # Look forward for timeout change (up to 15 seconds)
+        frame_interval = frame_data[1]["timestamp"] - frame_data[0]["timestamp"] if len(frame_data) > 1 else 0.5
+        max_frames_forward = int(15.0 / frame_interval) if frame_interval > 0 else 30
+
+        for j in range(frame_idx, min(len(frame_data), frame_idx + max_frames_forward)):
+            frame = frame_data[j]
+            if frame.get("home_timeouts") is not None:
+                after_home = frame.get("home_timeouts", 3)
+                after_away = frame.get("away_timeouts", 3)
+
+                if after_home < before_home:
+                    return "home"
+                if after_away < before_away:
+                    return "away"
+
+        return None
+
+    def _find_clock_reset_play_end(self, frame_data: List[Dict[str, Any]], frame_idx: int, max_duration: float) -> float:
+        """
+        Find the end time for a clock reset play (Class C special play).
+
+        The play ends when EITHER:
+        - Scorebug disappears (cut to commercial/replay)
+        - max_duration seconds have elapsed since play START
+
+        Args:
+            frame_data: Frame data list
+            frame_idx: Index of the frame where 40->25 reset occurred
+            max_duration: Maximum play duration from start
+
+        Returns:
+            Play end timestamp
+        """
+        start_timestamp = frame_data[frame_idx]["timestamp"]
+        max_end_time = start_timestamp + max_duration
+
+        # Look for scorebug disappearance (but cap at max_duration from start)
+        for j in range(frame_idx + 1, len(frame_data)):
+            frame = frame_data[j]
+            timestamp = frame["timestamp"]
+
+            # If we've exceeded max_duration, end the play at max_duration
+            if timestamp >= max_end_time:
+                return max_end_time
+
+            # Check for play clock disappearance
+            clock_available = frame.get("clock_detected", frame.get("scorebug_detected", False))
+            if not clock_available:
+                return timestamp
+
+        # Default: end at max_duration (or end of data if shorter)
+        return min(max_end_time, frame_data[-1]["timestamp"] if frame_data else max_end_time)
+
+    def _merge_plays(self, state_machine_plays: List[PlayEvent], clock_reset_plays: List[PlayEvent]) -> List[PlayEvent]:
+        """
+        Merge plays from state machine and clock reset detection, removing overlaps and duplicates.
+
+        Handles two types of duplicates:
+        1. Overlapping plays (start_time < last.end_time)
+        2. Close plays (start times within proximity_threshold) representing the same event
+
+        Args:
+            state_machine_plays: Plays from the state machine
+            clock_reset_plays: Plays from clock reset detection
+
+        Returns:
+            Merged list of plays sorted by start time
+        """
+        all_plays = list(state_machine_plays) + list(clock_reset_plays)
+        all_plays.sort(key=lambda p: p.start_time)
+
+        if not all_plays:
+            return []
+
+        # Proximity threshold: plays within this time are considered the same event
+        proximity_threshold = 5.0  # seconds
+
+        # Remove overlapping and close plays (keep state machine plays over clock reset plays)
+        filtered = [all_plays[0]]
+        for play in all_plays[1:]:
+            last = filtered[-1]
+
+            # Check for overlap OR proximity (both indicate same event)
+            is_overlapping = play.start_time < last.end_time
+            is_close = abs(play.start_time - last.start_time) < proximity_threshold
+
+            if is_overlapping or is_close:
+                # Same event detected twice - keep the better one
+                # Priority: normal > special > timeout (normal plays are most reliable)
+                type_priority = {"normal": 3, "special": 2, "timeout": 1}
+                last_priority = type_priority.get(last.play_type, 0)
+                play_priority = type_priority.get(play.play_type, 0)
+
+                if play_priority > last_priority:
+                    filtered[-1] = play  # Replace with higher priority play
+                elif play_priority == last_priority and play.confidence > last.confidence:
+                    filtered[-1] = play  # Same priority, but higher confidence
+                # else: keep existing
+            else:
+                filtered.append(play)
+
+        # Apply quiet time filter to remove false positives after normal plays
+        filtered = self._apply_quiet_time_filter(filtered)
+
+        # Renumber plays
+        for i, play in enumerate(filtered, 1):
+            play.play_number = i
+
+        return filtered
+
+    def _apply_quiet_time_filter(self, plays: List[PlayEvent], quiet_time: float = 10.0) -> List[PlayEvent]:
+        """
+        Apply quiet time filter after normal plays.
+
+        After a normal play ends, no new special/timeout plays can start for quiet_time seconds.
+        This filters out false positives from penalties during plays.
+
+        Args:
+            plays: List of plays sorted by start time
+            quiet_time: Seconds of quiet time after normal plays
+
+        Returns:
+            Filtered list of plays
+        """
+        if not plays:
+            return []
+
+        filtered = []
+        last_normal_end = -999.0  # Track when last normal play ended
+
+        for play in plays:
+            # Check if this play starts during quiet time after a normal play
+            if play.start_time < last_normal_end + quiet_time and play.play_type != "normal":
+                # This non-normal play starts during quiet time - filter it out
+                time_since_normal = play.start_time - last_normal_end
+                logger.debug(
+                    "Quiet time filter: Removing %s play at %.1fs (%.1fs after normal play ended)",
+                    play.play_type,
+                    play.start_time,
+                    time_since_normal,
+                )
+                continue
+
+            filtered.append(play)
+
+            # Update last normal play end time
+            if play.play_type == "normal":
+                last_normal_end = play.end_time
+
+        removed_count = len(plays) - len(filtered)
+        if removed_count > 0:
+            logger.info("Quiet time filter removed %d plays", removed_count)
+
+        return filtered
+
     def detect(self) -> DetectionResult:
         """
         Run play detection on the video segment.
@@ -565,11 +866,11 @@ class PlayDetector:
 
         # Streaming detection pass: read frames + template match + state machine (all in one)
         # Uses threaded video I/O to overlap reading with processing
-        # Note: Return value unused - state machine is updated inline during the pass
-        _ = self._streaming_detection_pass(context, stats, timing)
+        # Returns frame_data needed for post-hoc clock reset detection
+        frame_data = self._streaming_detection_pass(context, stats, timing)
 
-        # Finalize: Clock reset classification and result building
-        return self._finalize_detection(context, stats, timing)
+        # Finalize: Post-hoc clock reset classification (Class A/B/C) and result building
+        return self._finalize_detection(context, stats, timing, frame_data)
 
     # pylint: disable=too-many-locals
     def detect_parallel(self, num_workers: int = 2, output_dir: Optional[Path] = None) -> DetectionResult:
@@ -706,8 +1007,8 @@ class PlayDetector:
             "frames_with_clock": stats["frames_with_clock"],
         }
 
-        # Finalize: Clock reset classification and result building
-        return self._finalize_detection(context, stats_dict, timing)
+        # Finalize: Post-hoc clock reset classification (Class A/B/C) and result building
+        return self._finalize_detection(context, stats_dict, timing, frame_data)
 
     def _log_detection_mode(self) -> None:
         """Log the detection mode being used."""

src/readers/playclock.py

@@ -19,7 +19,7 @@ from typing import List, Tuple
 import cv2
 import numpy as np
 
-from setup import DigitTemplateLibrary
+from setup import DigitTemplate, DigitTemplateLibrary
 from utils import extract_center_region, extract_far_left_region, extract_left_region, extract_right_region, preprocess_playclock_region
 from .models import PlayClockReading, TemplateMatchResult, TemplatePlayClockReading
 
@@ -81,7 +81,7 @@ class ReadPlayClock:
         """
         return preprocess_playclock_region(region, self.scale_factor)
 
-    def match_digit(self, region: np.ndarray, templates: List) -> TemplateMatchResult:
+    def match_digit(self, region: np.ndarray, templates: List[DigitTemplate]) -> TemplateMatchResult:
         """
         Match a region against a set of digit templates.
 

src/setup/template_builder.py

@@ -9,7 +9,7 @@ Region extraction and preprocessing utilities are shared from utils to eliminate
 """
 
 import logging
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import cv2
 import numpy as np
@@ -296,7 +296,7 @@ class DigitTemplateBuilder:
 
         return library
 
-    def get_coverage_status(self) -> Dict[str, any]:
+    def get_coverage_status(self) -> Dict[str, Any]:
         """Get current sample coverage status."""
         # Get keys for samples that have at least one entry
         keys_with_samples = [key for key, samples in self.samples.items() if len(samples) >= 1]

src/setup/template_library.py

@@ -37,7 +37,7 @@ class DigitTemplateLibrary:
     TENS_DIGITS = [-1, 1, 2, 3, 4]  # -1 = blank, 1-4 for 10-40
     POSITIONS = ["left", "center", "right"]
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize empty template library."""
         # Templates: {(is_tens, digit_value, position): DigitTemplate}
         self.templates: Dict[Tuple[bool, int, str], DigitTemplate] = {}
@@ -107,20 +107,20 @@ class DigitTemplateLibrary:
         status = calculate_coverage_status(ones_center_have, ones_right_have, tens_have, has_blank, total_items=len(self.templates))
 
         # Convert -1 to "blank" for display
-        def format_tens(digits):
+        def format_tens(digits: set[int]) -> list[str | int]:
             return sorted(["blank" if d == -1 else d for d in digits], key=lambda x: (isinstance(x, str), x))
 
         # Add legacy fields for backward compatibility
         status["ones_have"] = sorted(ones_center_have | ones_right_have)
         status["ones_missing"] = sorted((ONES_DIGITS - ones_center_have) & (ONES_DIGITS - ones_right_have))
         status["tens_have_formatted"] = format_tens(tens_have | ({-1} if has_blank else set()))
-        status["tens_missing_formatted"] = format_tens((status["tens_missing"]) | (set() if has_blank else {-1}))
+        status["tens_missing_formatted"] = format_tens(set(status["tens_missing"]) | (set() if has_blank else {-1}))
 
         return status
 
     def is_complete(self) -> bool:
         """Check if all required templates are present."""
-        return self.get_coverage_status()["is_complete"]
+        return bool(self.get_coverage_status()["is_complete"])
 
     def save(self, output_path: str) -> None:
         """
@@ -132,7 +132,7 @@ class DigitTemplateLibrary:
         output_dir = Path(output_path)
         output_dir.mkdir(parents=True, exist_ok=True)
 
-        metadata = {"templates": [], "version": 2}  # Version 2 includes position
+        templates_list: list[dict[str, object]] = []
 
         for (is_tens, digit, position), template in self.templates.items():
             # Use "blank" instead of -1 for the empty tens digit in filenames
@@ -140,7 +140,7 @@ class DigitTemplateLibrary:
             position_suffix = f"_{position}" if position != "left" or not is_tens else ""
             filename = f"{'tens' if is_tens else 'ones'}_{digit_str}{position_suffix}.png"
             cv2.imwrite(str(output_dir / filename), template.template)
-            metadata["templates"].append(
+            templates_list.append(
                 {
                     "filename": filename,
                     "digit_value": digit_str,  # Use "blank" for display
@@ -151,6 +151,8 @@ class DigitTemplateLibrary:
                 }
             )
 
+        metadata = {"templates": templates_list, "version": 2}  # Version 2 includes position
+
         with open(output_dir / "templates_metadata.json", "w", encoding="utf-8") as f:
             json.dump(metadata, f, indent=2)
 

src/tracking/play_state.py

@@ -315,7 +315,7 @@ class TrackPlayState:
             self._start_play(timestamp, "clock_reset_special", 40)
 
         # Play tracking is started, not completed - no PlayEvent to return
-        # (implicitly returns None)
+        return None
 
     def _check_timeout_change(self, timeout_info: Optional[TimeoutInfo] = None) -> Optional[str]:
         """
@@ -373,6 +373,8 @@ class TrackPlayState:
 
     def _check_play_timeout(self, timestamp: float, clock_value: int) -> Optional[PlayEvent]:
         """Check if play duration has exceeded maximum allowed time."""
+        if self._state.current_play_start_time is None:
+            return None  # No play in progress
         play_duration = timestamp - self._state.current_play_start_time
         if play_duration > self.config.max_play_duration:
             # Cap the end time at start + max_duration to avoid inflated durations
@@ -702,7 +704,7 @@ class TrackPlayState:
         """Get current state."""
         return self._state.state
 
-    def get_stats(self) -> dict:
+    def get_stats(self) -> dict[str, object]:
         """Get statistics about detected plays."""
         if not self._state.plays:
             return {"total_plays": 0, "clock_reset_events": self._state.clock_reset_stats.model_dump()}

src/ui/api.py

@@ -19,7 +19,7 @@ from .sessions import PlayClockSelectionSession, ScorebugSelectionSession, Timeo
 logger = logging.getLogger(__name__)
 
 
-def print_banner():
+def print_banner() -> None:
     """Print the welcome banner for CFB40."""
     print("\n" + "=" * 60)
     print("   CFB40 - College Football Play Detection Pipeline")
@@ -31,7 +31,7 @@ def extract_sample_frames_for_selection(video_path: str, start_time: float, num_
     return extract_sample_frames(video_path, start_time, num_frames, interval)
 
 
-def select_scorebug_region(frames: List[Tuple[float, np.ndarray]], video_path: str = None) -> Tuple[Optional[Tuple[int, int, int, int]], Optional[Tuple[float, np.ndarray]]]:
+def select_scorebug_region(frames: List[Tuple[float, np.ndarray]], video_path: str | None = None) -> Tuple[Optional[Tuple[int, int, int, int]], Optional[Tuple[float, np.ndarray]]]:
     """
     Interactive selection of scorebug region.
 

src/ui/selector.py

@@ -41,7 +41,7 @@ class RegionSelector:
 
         self.selection_complete = False
 
-    def mouse_callback(self, event, x, y, _flags, _param):
+    def mouse_callback(self, event: int, x: int, y: int, _flags: int, _param: object) -> None:
         """Handle mouse events for region selection."""
         if self.mode == "two_click":
             if event == cv2.EVENT_MOUSEMOVE:
@@ -79,7 +79,7 @@ class RegionSelector:
             return None
         return bbox
 
-    def reset(self):
+    def reset(self) -> None:
         """Reset the selection state."""
         self.points = []
         self.current_point = None

src/utils/color.py

@@ -41,7 +41,7 @@ def detect_red_digits(region: np.ndarray) -> bool:
 
     # Red digits: high red channel, very low green/blue, red > 2x green
     max_gb = max(g_mean, b_mean)
-    is_red = r_mean > 15 > max_gb and r_mean > g_mean * 2
+    is_red = bool(r_mean > 15 > max_gb and r_mean > g_mean * 2)
 
     if is_red:
         logger.debug("Red digits detected: R=%.1f, G=%.1f, B=%.1f", r_mean, g_mean, b_mean)

src/video/ffmpeg_ops.py

@@ -146,7 +146,7 @@ def extract_clip_reencode(
         return (False, error_msg)
 
 
-def _extract_clip_for_parallel(args: Tuple[int, Dict, str, Path, float]) -> Tuple[int, Path, bool, str]:
+def _extract_clip_for_parallel(args: Tuple[int, Dict[str, Any], str, Path, float]) -> Tuple[int, Path, bool, str]:
     """
     Extract a single clip using stream copy (for parallel execution).
 
@@ -273,7 +273,7 @@ def _generate_clips_reencode(
     return clip_paths
 
 
-def concatenate_clips(clip_paths: List[Path], output_path: Path, working_dir: Path = None) -> Tuple[bool, str]:
+def concatenate_clips(clip_paths: List[Path], output_path: Path, working_dir: Path | None = None) -> Tuple[bool, str]:
     """
     Concatenate multiple video clips into a single video.
 

src/video/frame_extractor.py

@@ -7,7 +7,7 @@ getting video metadata, and other video-related utilities.
 
 import logging
 import subprocess
-from typing import List, Optional, Tuple
+from typing import Callable, List, Optional, Tuple
 
 import cv2
 import numpy as np
@@ -161,7 +161,7 @@ def extract_frames_with_callback(
     start_time: float,
     end_time: Optional[float],
     interval: float,
-    callback,
+    callback: Callable[[float, np.ndarray], bool],
 ) -> int:
     """
     Extract frames from a video and call a callback function for each frame.