Fixing mypy

src/detection/timeout_calibrator.py

@@ -14,7 +14,7 @@ The calibration process:
 """
 
 import logging
-from typing import Any, List, Optional, Tuple
+from typing import Any, List, Optional, Tuple, cast
 
 import cv2
 import numpy as np
@@ -86,6 +86,7 @@ def calibrate_timeout_ovals(
 
     return calibrated
 
+
 # pylint: disable=too-many-locals
 def _find_bright_ovals(roi: np.ndarray[Any, Any]) -> List[OvalLocation]:
     """
@@ -148,7 +149,9 @@ def _find_bright_ovals(roi: np.ndarray[Any, Any]) -> List[OvalLocation]:
         # Calculate mean brightness of the contour region
         mask = np.zeros(gray.shape, dtype=np.uint8)
         cv2.drawContours(mask, [contour], -1, 255, -1)
-        mean_brightness = cv2.mean(gray, mask=mask)[0]
+        # cv2.mean returns a tuple of 4 floats (per channel); extract the first channel
+        mean_brightness_tuple = cast(Tuple[float, float, float, float], cv2.mean(gray, mask=mask))
+        mean_brightness = mean_brightness_tuple[0]
 
         # Only keep if significantly bright
         if mean_brightness < 100:
@@ -168,8 +171,11 @@ def _find_bright_ovals(roi: np.ndarray[Any, Any]) -> List[OvalLocation]:
 
     logger.debug("Found %d candidate ovals in region", len(ovals))
     return ovals
+
+
 # pylint: enable=too-many-locals
 
+
 def _validate_oval_pattern(ovals: List[OvalLocation]) -> bool:
     """
     Validate that ovals have consistent spacing (symmetry check).
@@ -259,7 +265,7 @@ def check_oval_brightness(
 
     # Convert to grayscale and calculate mean brightness
     gray = cv2.cvtColor(oval_roi, cv2.COLOR_BGR2GRAY)
-    current_brightness = float(np.mean(gray))
+    current_brightness = float(np.mean(np.asarray(gray)))
 
     # Compare to baseline
     threshold = oval.baseline_brightness * brightness_threshold_ratio

src/detection/timeouts.py

@@ -513,7 +513,7 @@ class CalibratedTimeoutDetector:
 
         # Convert to grayscale and calculate mean brightness
         gray = cv2.cvtColor(oval_roi, cv2.COLOR_BGR2GRAY)
-        current_brightness = float(np.mean(gray))
+        current_brightness = float(np.mean(np.asarray(gray)))
 
         # Compare to baseline
         threshold = oval.baseline_brightness * self.BRIGHTNESS_THRESHOLD_RATIO

src/pipeline/parallel.py

@@ -13,8 +13,9 @@ import time
 from concurrent.futures import Future, ProcessPoolExecutor, as_completed
 from multiprocessing import Manager
 from pathlib import Path
-from typing import Any, Dict, List, MutableMapping, Optional, Tuple
+from typing import Any, Dict, List, MutableMapping, Optional, Tuple, Union
 
+from detection.timeouts import CalibratedTimeoutDetector
 from utils import create_frame_result
 from .models import ChunkResult, ParallelProcessingConfig
 
@@ -25,6 +26,7 @@ logger = logging.getLogger(__name__)
 # Chunk Processing Helper Functions (run in subprocess)
 # =============================================================================
 
+
 # pylint: disable=too-many-locals
 def _init_chunk_detectors(config: ParallelProcessingConfig) -> Tuple[Any, Any, Any, Any, Any]:
     """
@@ -76,10 +78,9 @@ def _init_chunk_detectors(config: ParallelProcessingConfig) -> Tuple[Any, Any, A
 
     # Initialize timeout tracker if config provided
     # Try calibrated detector first (with oval positions), fall back to legacy
-    timeout_tracker = None
-    if config.timeout_config_path and Path(config.timeout_config_path).exists():
-        from detection.timeouts import CalibratedTimeoutDetector
 
+    timeout_tracker: Optional[Union[CalibratedTimeoutDetector, DetectTimeouts]] = None
+    if config.timeout_config_path and Path(config.timeout_config_path).exists():
         # Try to load as calibrated detector first
         calibrated = CalibratedTimeoutDetector(config_path=config.timeout_config_path)
         if calibrated.is_configured():
@@ -99,8 +100,11 @@ def _init_chunk_detectors(config: ParallelProcessingConfig) -> Tuple[Any, Any, A
         )
 
     return scorebug_detector, clock_reader, template_reader, timeout_tracker, flag_reader
+
+
 # pylint: enable=too-many-locals
 
+
 def _process_frame(
     img: Any,
     timestamp: float,

src/pipeline/play_extractor.py

@@ -21,12 +21,13 @@ import json
 import logging
 import time
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Tuple
+from typing import Optional, List, Dict, Any, Tuple, Union
 
 import cv2
 import numpy as np
 
 from detection import DetectScoreBug, ScorebugDetection, DetectTimeouts
+from detection.timeouts import CalibratedTimeoutDetector
 from readers import FlagReader, ReadPlayClock, PlayClockReading
 from setup import DigitTemplateBuilder, DigitTemplateLibrary, PlayClockRegionConfig, PlayClockRegionExtractor
 from tracking import FlagInfo, TrackPlayState, PlayEvent, PlayMerger, TimeoutInfo, ClockResetIdentifier
@@ -75,7 +76,7 @@ class PlayExtractor:
     - ClockResetIdentifier: Post-hoc identification of timeout/special plays
     """
 
-    def __init__(self, config: DetectionConfig, timeout_tracker: Optional[DetectTimeouts] = None, flag_reader: Optional[FlagReader] = None):
+    def __init__(self, config: DetectionConfig, timeout_tracker: Optional[Union[CalibratedTimeoutDetector, DetectTimeouts]] = None, flag_reader: Optional[FlagReader] = None):
         """
         Initialize the play extractor pipeline.
 
@@ -85,7 +86,7 @@ class PlayExtractor:
             flag_reader: Optional FLAG reader for penalty flag detection
         """
         self.config = config
-        self.timeout_tracker = timeout_tracker
+        self.timeout_tracker: Optional[Union[CalibratedTimeoutDetector, DetectTimeouts]] = timeout_tracker
         self.flag_reader = flag_reader
 
         # Template-based clock reading components (conditionally initialized)

src/readers/flags.py

@@ -158,7 +158,7 @@ class FlagReader:
         # Compute mean hue of yellow pixels
         if yellow_pixels > 0:
             yellow_hues = hsv[:, :, 0][mask > 0]
-            mean_hue = float(np.mean(yellow_hues))
+            mean_hue = float(np.mean(np.asarray(yellow_hues)))
         else:
             mean_hue = 0.0
 

src/tracking/flag_tracker.py

@@ -177,7 +177,7 @@ class FlagTracker:
         # No scorebug (e.g., replay) - use gap tolerance
         return self._handle_no_scorebug(timestamp)
 
-    def _handle_flag_detected(self, timestamp: float, flag_info: FlagInfo) -> Optional[PlayEvent]:
+    def _handle_flag_detected(self, timestamp: float, flag_info: FlagInfo) -> Optional[PlayEvent]: # pylint: disable=useless-return
         """Handle FLAG being detected."""
         self._last_flag_seen_at = timestamp
 
@@ -197,6 +197,8 @@ class FlagTracker:
         if self._state.current_flag is not None:
             self._state.current_flag.update(flag_info.yellow_ratio, flag_info.mean_hue)
 
+        return None
+
     def _handle_flag_cleared(self, timestamp: float) -> Optional[PlayEvent]:
         """Handle FLAG being cleared (scorebug visible, no FLAG)."""
         if not self._state.flag_active:

src/tracking/play_state.py

@@ -21,7 +21,7 @@ The API remains backward compatible with the original implementation.
 """
 
 import logging
-from typing import Optional, List
+from typing import Any, Dict, List, Optional
 
 from detection import ScorebugDetection
 from readers import PlayClockReading
@@ -124,7 +124,7 @@ class TrackPlayState:
         """Get current state."""
         return self._tracker.get_state()
 
-    def get_stats(self) -> dict:
+    def get_stats(self) -> Dict[str, Any]:
         """Get statistics about tracked plays."""
         return self._tracker.get_stats()
 

src/tracking/play_tracker.py

@@ -23,7 +23,7 @@ FLAG tracking runs in parallel:
 """
 
 import logging
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 from detection import ScorebugDetection
 from readers import PlayClockReading
@@ -33,6 +33,7 @@ from .models import (
     FlagInfo,
     PlayEvent,
     PlayState,
+    SpecialPlayHandoff,
     TimeoutInfo,
     TrackerMode,
     TrackPlayStateConfig,
@@ -109,7 +110,7 @@ class PlayTracker:
         return self._special_tracker.stats
 
     @property
-    def flag_tracker_stats(self) -> dict:
+    def flag_tracker_stats(self) -> Dict[str, Any]:
         """Statistics about FLAG tracking."""
         return self._flag_tracker.get_stats()
 
@@ -223,7 +224,7 @@ class PlayTracker:
     # Mode transitions
     # =========================================================================
 
-    def _activate_special_mode(self, handoff) -> None:
+    def _activate_special_mode(self, handoff: SpecialPlayHandoff) -> None:
         """
         Activate special mode to handle a 40→25 transition.
 
@@ -284,7 +285,7 @@ class PlayTracker:
         """Get current state of normal tracker."""
         return self._normal_tracker.state
 
-    def get_stats(self) -> dict:
+    def get_stats(self) -> Dict[str, Any]:
         """Get statistics about tracked plays."""
         if not self._plays:
             return {

src/tracking/special_play_tracker.py

@@ -54,7 +54,7 @@ class SpecialPlayTracker:
     # Timeout confirmation requirement
     MIN_CONSECUTIVE_TIMEOUT_CONFIRMATIONS = 3  # Require k consecutive frames showing same timeout decrease
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the special play tracker."""
         self._state = SpecialTrackerState()
         self._play_count = 0  # Running count for play numbering
@@ -224,8 +224,12 @@ class SpecialPlayTracker:
         # Check for timeout indicator change
         if timeout_info is not None and timeout_info.confidence >= 0.5:
             # Debug: log what we're seeing
-            home_change = (self._state.home_timeouts_at_40 or 0) - timeout_info.home_timeouts
-            away_change = (self._state.away_timeouts_at_40 or 0) - timeout_info.away_timeouts
+            home_baseline = self._state.home_timeouts_at_40 if self._state.home_timeouts_at_40 is not None else 0
+            away_baseline = self._state.away_timeouts_at_40 if self._state.away_timeouts_at_40 is not None else 0
+            current_home = timeout_info.home_timeouts if timeout_info.home_timeouts is not None else 0
+            current_away = timeout_info.away_timeouts if timeout_info.away_timeouts is not None else 0
+            home_change = home_baseline - current_home
+            away_change = away_baseline - current_away
             logger.debug(
                 "SpecialPlayTracker check at %.1fs: before(H=%s,A=%s) after(H=%s,A=%s,conf=%.2f) | Δh=%+d Δa=%+d",
                 timestamp,