Update app.py

app.py

@@ -45,14 +45,15 @@ print(f"🖥️ Using device: {DEVICE}")
 # ==============================================
 CLIENT = InferenceHTTPClient(
     api_url="https://detect.roboflow.com",
-    api_key=ROBOFLOW_API_KEY
+    api_key=ROBOFLOW_API_KEY,
 )
 
 PLAYER_DETECTION_MODEL_ID = "football-players-detection-3zvbc/11"
 FIELD_DETECTION_MODEL_ID = "football-field-detection-f07vi/14"
 
+
 def infer_with_confidence(model_id: str, frame: np.ndarray, confidence_threshold: float = 0.3):
-    """Run inference and filter by confidence threshold"""
+    """Run inference and filter by confidence threshold."""
     result = CLIENT.infer(frame, model_id=model_id)
     detections = sv.Detections.from_inference(result)
     # Filter by confidence
@@ -60,6 +61,7 @@ def infer_with_confidence(model_id: str, frame: np.ndarray, confidence_threshold
         detections = detections[detections.confidence > confidence_threshold]
     return result, detections
 
+
 # ==============================================
 # SIGLIP MODEL (Embeddings)
 # ==============================================
@@ -74,7 +76,6 @@ CONFIG = SoccerPitchConfiguration()
 
 # ==============================================
 # TABLE HEADERS FOR GRADIO DATAFRAMES
-# (IMPORTANT: col_count MUST equal len(headers))
 # ==============================================
 PLAYER_STATS_HEADERS = [
     "Player ID",
@@ -107,9 +108,9 @@ EVENT_HEADERS = [
 # ==============================================
 def replace_outliers_based_on_distance(
     positions: List[np.ndarray],
-    distance_threshold: float
+    distance_threshold: float,
 ) -> List[np.ndarray]:
-    """Remove outlier positions based on distance threshold"""
+    """Remove outlier positions based on distance threshold."""
     last_valid_position: Union[np.ndarray, None] = None
     cleaned_positions: List[np.ndarray] = []
 
@@ -130,6 +131,7 @@ def replace_outliers_based_on_distance(
 
     return cleaned_positions
 
+
 # ==============================================
 # PITCH DISTANCE (UNITS FIX: meters)
 # ==============================================
@@ -149,37 +151,40 @@ def pitch_distance_m(p1: np.ndarray, p2: np.ndarray) -> float:
     else:
         return d
 
+
 # ==============================================
 # PLAYER PERFORMANCE TRACKING
 # ==============================================
 class PlayerPerformanceTracker:
-    """Track individual player performance metrics and generate heatmaps"""
-    
+    """Track individual player performance metrics and generate heatmaps."""
+
     def __init__(self, pitch_config, fps: float = 30.0):
         self.config = pitch_config
         self.fps = fps
         self.player_positions = defaultdict(list)
-        self.player_velocities = defaultdict(list)   # km/h
-        self.player_distances = defaultdict(float)   # meters
+        self.player_velocities = defaultdict(list)  # km/h
+        self.player_distances = defaultdict(float)  # meters
         self.player_team = {}
-        self.player_stats = defaultdict(lambda: {
-            'frames_visible': 0,
-            'avg_velocity': 0.0,          # km/h
-            'max_velocity': 0.0,          # km/h
-            'time_in_attacking_third': 0,
-            'time_in_defensive_third': 0,
-            'time_in_middle_third': 0
-        })
-        
+        self.player_stats = defaultdict(
+            lambda: {
+                "frames_visible": 0,
+                "avg_velocity": 0.0,  # km/h
+                "max_velocity": 0.0,  # km/h
+                "time_in_attacking_third": 0,
+                "time_in_defensive_third": 0,
+                "time_in_middle_third": 0,
+            }
+        )
+
     def update(self, tracker_id: int, position: np.ndarray, team_id: int, frame: int):
-        """Update player position and calculate metrics"""
+        """Update player position and calculate metrics."""
         if len(position) != 2:
             return
-            
+
         self.player_team[tracker_id] = team_id
         self.player_positions[tracker_id].append((position[0], position[1], frame))
-        self.player_stats[tracker_id]['frames_visible'] += 1
-        
+        self.player_stats[tracker_id]["frames_visible"] += 1
+
         if len(self.player_positions[tracker_id]) > 1:
             prev_pos = np.array(self.player_positions[tracker_id][-2][:2], dtype=float)
             curr_pos = np.array(position, dtype=float)
@@ -187,254 +192,309 @@ class PlayerPerformanceTracker:
             # distance in meters between frames
             distance_m = pitch_distance_m(prev_pos, curr_pos)
             self.player_distances[tracker_id] += distance_m
-            
+
             # speed in km/h
             speed_mps = distance_m * self.fps
             speed_kmh = speed_mps * 3.6
             self.player_velocities[tracker_id].append(speed_kmh)
-            
-            if speed_kmh > self.player_stats[tracker_id]['max_velocity']:
-                self.player_stats[tracker_id]['max_velocity'] = speed_kmh
-        
+
+            if speed_kmh > self.player_stats[tracker_id]["max_velocity"]:
+                self.player_stats[tracker_id]["max_velocity"] = speed_kmh
+
         pitch_length = self.config.length
         if position[0] < pitch_length / 3:
-            self.player_stats[tracker_id]['time_in_defensive_third'] += 1
+            self.player_stats[tracker_id]["time_in_defensive_third"] += 1
         elif position[0] < 2 * pitch_length / 3:
-            self.player_stats[tracker_id]['time_in_middle_third'] += 1
+            self.player_stats[tracker_id]["time_in_middle_third"] += 1
         else:
-            self.player_stats[tracker_id]['time_in_attacking_third'] += 1
-    
+            self.player_stats[tracker_id]["time_in_attacking_third"] += 1
+
     def get_player_stats(self, tracker_id: int) -> dict:
-        """Get comprehensive stats for a player"""
+        """Get comprehensive stats for a player."""
         stats = self.player_stats[tracker_id].copy()
-        
+
         if len(self.player_velocities[tracker_id]) > 0:
-            stats['avg_velocity'] = float(np.mean(self.player_velocities[tracker_id]))
-        
-        stats['total_distance_meters'] = float(self.player_distances[tracker_id])
-        stats['team_id'] = int(self.player_team.get(tracker_id, -1))
-        
+            stats["avg_velocity"] = float(np.mean(self.player_velocities[tracker_id]))
+
+        stats["total_distance_meters"] = float(self.player_distances[tracker_id])
+        stats["team_id"] = int(self.player_team.get(tracker_id, -1))
+
         return stats
-    
+
     def generate_heatmap(self, tracker_id: int, resolution: int = 100) -> np.ndarray:
-        """Generate heatmap for a specific player"""
+        """Generate heatmap for a specific player."""
         if tracker_id not in self.player_positions or len(self.player_positions[tracker_id]) == 0:
             return np.zeros((resolution, resolution))
-        
+
         positions = np.array([(x, y) for x, y, _ in self.player_positions[tracker_id]])
-        
+
         pitch_length = self.config.length
         pitch_width = self.config.width
-        
+
         heatmap, xedges, yedges = np.histogram2d(
-            positions[:, 0], positions[:, 1],
+            positions[:, 0],
+            positions[:, 1],
             bins=[resolution, resolution],
-            range=[[0, pitch_length], [0, pitch_width]]
+            range=[[0, pitch_length], [0, pitch_width]],
         )
-        
+
         heatmap = gaussian_filter(heatmap, sigma=3)
-        
+
         return heatmap.T
-    
+
     def get_all_players_by_team(self) -> Dict[int, List[int]]:
-        """Get all player IDs grouped by team"""
+        """Get all player IDs grouped by team."""
         teams = defaultdict(list)
         for tracker_id, team_id in self.player_team.items():
             teams[team_id].append(tracker_id)
         return teams
 
+
 # ==============================================
 # TRACKING MANAGER
 # ==============================================
 class PlayerTrackingManager:
-    """Manages persistent player tracking with team assignment stability"""
-    
+    """Manages persistent player tracking with team assignment stability."""
+
     def __init__(self, max_history=10):
         self.tracker_team_history: Dict[int, List[int]] = defaultdict(list)
         self.max_history = max_history
         self.active_trackers = set()
-        
+
     def update_team_assignment(self, tracker_id: int, team_id: int):
-        """Store team assignment history for each tracker"""
+        """Store team assignment history for each tracker."""
         self.tracker_team_history[tracker_id].append(team_id)
         if len(self.tracker_team_history[tracker_id]) > self.max_history:
             self.tracker_team_history[tracker_id].pop(0)
         self.active_trackers.add(tracker_id)
-    
+
     def get_stable_team_id(self, tracker_id: int, current_team_id: int) -> int:
-        """Get stable team ID using majority voting from history"""
+        """Get stable team ID using majority voting from history."""
         if tracker_id not in self.tracker_team_history or len(self.tracker_team_history[tracker_id]) < 3:
             return current_team_id
-        
+
         history = self.tracker_team_history[tracker_id]
         team_counts = np.bincount(history)
         stable_team = int(np.argmax(team_counts))
         return stable_team
-    
+
     def get_player_count_by_team(self) -> Dict[int, int]:
-        """Get current count of players per team"""
+        """Get current count of players per team."""
         team_counts = defaultdict(int)
         for tracker_id in self.active_trackers:
             if tracker_id in self.tracker_team_history and len(self.tracker_team_history[tracker_id]) > 0:
-                stable_team = self.get_stable_team_id(tracker_id, self.tracker_team_history[tracker_id][-1])
+                stable_team = self.get_stable_team_id(
+                    tracker_id,
+                    self.tracker_team_history[tracker_id][-1],
+                )
                 team_counts[stable_team] += 1
         return team_counts
-    
+
     def reset_frame(self):
-        """Reset active trackers for new frame"""
+        """Reset active trackers for new frame."""
         self.active_trackers = set()
 
+
 # ==============================================
 # VISUALIZATION FUNCTIONS
 # ==============================================
-def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTracker, 
-                                       tracker_id: int) -> np.ndarray:
-    """Create a single player heatmap overlay on pitch"""
+def create_player_heatmap_visualization(
+    performance_tracker: PlayerPerformanceTracker,
+    tracker_id: int,
+) -> np.ndarray:
+    """Create a single player heatmap overlay on pitch."""
     pitch = draw_pitch(CONFIG)
     heatmap = performance_tracker.generate_heatmap(tracker_id, resolution=150)
-    
+
     if heatmap.max() > 0:
         heatmap = heatmap / heatmap.max()
-    
+
     padding = 50
-    
+
     pitch_height, pitch_width = pitch.shape[:2]
-    heatmap_resized = cv2.resize(heatmap, (pitch_width - 2*padding, pitch_height - 2*padding))
-    
+    heatmap_resized = cv2.resize(heatmap, (pitch_width - 2 * padding, pitch_height - 2 * padding))
+
     heatmap_colored = cv2.applyColorMap((heatmap_resized * 255).astype(np.uint8), cv2.COLORMAP_JET)
-    
+
     overlay = pitch.copy()
-    overlay[padding:pitch_height-padding, padding:pitch_width-padding] = heatmap_colored
-    
+    overlay[padding : pitch_height - padding, padding : pitch_width - padding] = heatmap_colored
+
     result = cv2.addWeighted(pitch, 0.6, overlay, 0.4, 0)
-    
+
     stats = performance_tracker.get_player_stats(tracker_id)
-    team_color = "Blue" if stats['team_id'] == 0 else "Pink"
-    
+    team_color = "Blue" if stats["team_id"] == 0 else "Pink"
+
     text_lines = [
         f"Player #{tracker_id} ({team_color} Team)",
         f"Distance: {stats['total_distance_meters']:.1f} m",
         f"Avg Speed: {stats['avg_velocity']:.2f} km/h",
         f"Max Speed: {stats['max_velocity']:.2f} km/h",
-        f"Frames: {stats['frames_visible']}"
+        f"Frames: {stats['frames_visible']}",
     ]
-    
+
     y_offset = 30
     for line in text_lines:
-        cv2.putText(result, line, (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 
-                   0.6, (255, 255, 255), 2, cv2.LINE_AA)
+        cv2.putText(
+            result,
+            line,
+            (10, y_offset),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.6,
+            (255, 255, 255),
+            2,
+            cv2.LINE_AA,
+        )
         y_offset += 25
-    
+
     return result
 
 
 def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker) -> go.Figure:
-    """Create interactive performance comparison plots"""
+    """Create interactive performance comparison plots."""
     teams = performance_tracker.get_all_players_by_team()
-    
+
     fig = make_subplots(
-        rows=2, cols=2,
-        subplot_titles=('Distance Covered', 'Average Speed', 'Max Speed', 'Activity by Zone'),
-        specs=[[{'type': 'bar'}, {'type': 'bar'}],
-               [{'type': 'bar'}, {'type': 'bar'}]]
+        rows=2,
+        cols=2,
+        subplot_titles=(
+            "Distance Covered",
+            "Average Speed",
+            "Max Speed",
+            "Activity by Zone",
+        ),
+        specs=[[{"type": "bar"}, {"type": "bar"}], [{"type": "bar"}, {"type": "bar"}]],
     )
-    
-    colors = {0: '#00BFFF', 1: '#FF1493'}
-    team_names = {0: 'Team 0 (Blue)', 1: 'Team 1 (Pink)'}
-    
+
+    colors = {0: "#00BFFF", 1: "#FF1493"}
+    team_names = {0: "Team 0 (Blue)", 1: "Team 1 (Pink)"}
+
     for team_id, player_ids in teams.items():
         if team_id not in [0, 1]:
             continue
-            
+
         distances = []
         avg_speeds = []
         max_speeds = []
         attacking_time = []
-        
+
         for pid in player_ids:
             stats = performance_tracker.get_player_stats(pid)
-            distances.append(stats['total_distance_meters'])
-            avg_speeds.append(stats['avg_velocity'])   # km/h
-            max_speeds.append(stats['max_velocity'])   # km/h
-            attacking_time.append(stats['time_in_attacking_third'])
-        
+            distances.append(stats["total_distance_meters"])
+            avg_speeds.append(stats["avg_velocity"])  # km/h
+            max_speeds.append(stats["max_velocity"])  # km/h
+            attacking_time.append(stats["time_in_attacking_third"])
+
         player_labels = [f"#{pid}" for pid in player_ids]
-        
+
         fig.add_trace(
-            go.Bar(x=player_labels, y=distances, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=True),
-            row=1, col=1
+            go.Bar(
+                x=player_labels,
+                y=distances,
+                name=team_names[team_id],
+                marker_color=colors[team_id],
+                showlegend=True,
+            ),
+            row=1,
+            col=1,
         )
-        
+
         fig.add_trace(
-            go.Bar(x=player_labels, y=avg_speeds, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=False),
-            row=1, col=2
+            go.Bar(
+                x=player_labels,
+                y=avg_speeds,
+                name=team_names[team_id],
+                marker_color=colors[team_id],
+                showlegend=False,
+            ),
+            row=1,
+            col=2,
         )
-        
+
         fig.add_trace(
-            go.Bar(x=player_labels, y=max_speeds, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=False),
-            row=2, col=1
+            go.Bar(
+                x=player_labels,
+                y=max_speeds,
+                name=team_names[team_id],
+                marker_color=colors[team_id],
+                showlegend=False,
+            ),
+            row=2,
+            col=1,
         )
-        
+
         fig.add_trace(
-            go.Bar(x=player_labels, y=attacking_time, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=False),
-            row=2, col=2
+            go.Bar(
+                x=player_labels,
+                y=attacking_time,
+                name=team_names[team_id],
+                marker_color=colors[team_id],
+                showlegend=False,
+            ),
+            row=2,
+            col=2,
         )
-    
+
     fig.update_xaxes(title_text="Players", row=1, col=1)
     fig.update_xaxes(title_text="Players", row=1, col=2)
     fig.update_xaxes(title_text="Players", row=2, col=1)
     fig.update_xaxes(title_text="Players", row=2, col=2)
-    
+
     fig.update_yaxes(title_text="Distance (m)", row=1, col=1)
     fig.update_yaxes(title_text="Speed (km/h)", row=1, col=2)
     fig.update_yaxes(title_text="Speed (km/h)", row=2, col=1)
     fig.update_yaxes(title_text="Frames in Zone", row=2, col=2)
-    
-    fig.update_layout(height=800, title_text="Team Performance Comparison", barmode='group')
-    
+
+    fig.update_layout(height=800, title_text="Team Performance Comparison", barmode="group")
+
     return fig
 
 
 def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> np.ndarray:
-    """Create side-by-side team heatmaps"""
+    """Create side-by-side team heatmaps."""
     teams = performance_tracker.get_all_players_by_team()
-    
+
     team_heatmaps = []
     for team_id in [0, 1]:
         if team_id not in teams:
             continue
-            
+
         combined_heatmap = np.zeros((150, 150))
         for pid in teams[team_id]:
             player_heatmap = performance_tracker.generate_heatmap(pid, resolution=150)
             combined_heatmap += player_heatmap
-        
+
         if combined_heatmap.max() > 0:
             combined_heatmap = combined_heatmap / combined_heatmap.max()
-        
+
         pitch = draw_pitch(CONFIG)
         padding = 50
         pitch_height, pitch_width = pitch.shape[:2]
-        heatmap_resized = cv2.resize(combined_heatmap, 
-                                    (pitch_width - 2*padding, pitch_height - 2*padding))
-        
+        heatmap_resized = cv2.resize(
+            combined_heatmap,
+            (pitch_width - 2 * padding, pitch_height - 2 * padding),
+        )
+
         colormap = cv2.COLORMAP_JET if team_id == 0 else cv2.COLORMAP_HOT
         heatmap_colored = cv2.applyColorMap((heatmap_resized * 255).astype(np.uint8), colormap)
-        
+
         overlay = pitch.copy()
-        overlay[padding:pitch_height-padding, padding:pitch_width-padding] = heatmap_colored
+        overlay[padding : pitch_height - padding, padding : pitch_width - padding] = heatmap_colored
         result = cv2.addWeighted(pitch, 0.5, overlay, 0.5, 0)
-        
+
         team_name = "Team 0 (Blue)" if team_id == 0 else "Team 1 (Pink)"
-        cv2.putText(result, team_name, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
-                   1, (255, 255, 255), 2, cv2.LINE_AA)
-        
+        cv2.putText(
+            result,
+            team_name,
+            (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1,
+            (255, 255, 255),
+            2,
+            cv2.LINE_AA,
+        )
+
         team_heatmaps.append(result)
-    
+
     if len(team_heatmaps) == 2:
         return np.hstack(team_heatmaps)
     elif len(team_heatmaps) == 1:
@@ -442,28 +502,36 @@ def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> n
     else:
         return draw_pitch(CONFIG)
 
+
 # ==============================================
 # HELPER FUNCTIONS
 # ==============================================
 def resolve_goalkeepers_team_id(players: sv.Detections, goalkeepers: sv.Detections) -> np.ndarray:
-    """Assign goalkeepers to the nearest team centroid"""
+    """Assign goalkeepers to the nearest team centroid."""
     if len(goalkeepers) == 0 or len(players) == 0:
         return np.array([])
     goalkeepers_xy = goalkeepers.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
     players_xy = players.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
     team_0_centroid = players_xy[players.class_id == 0].mean(axis=0)
     team_1_centroid = players_xy[players.class_id == 1].mean(axis=0)
-    return np.array([
-        0 if np.linalg.norm(gk - team_0_centroid) < np.linalg.norm(gk - team_1_centroid) else 1
-        for gk in goalkeepers_xy
-    ])
+    return np.array(
+        [
+            0 if np.linalg.norm(gk - team_0_centroid) < np.linalg.norm(gk - team_1_centroid) else 1
+            for gk in goalkeepers_xy
+        ]
+    )
 
 
-def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id, 
-                           pitch_referees_xy, ball_path=None):
-    """Create game-style radar view with ball trail effect"""
+def create_game_style_radar(
+    pitch_ball_xy,
+    pitch_players_xy,
+    players_class_id,
+    pitch_referees_xy,
+    ball_path=None,
+):
+    """Create game-style radar view with ball trail effect."""
     annotated_frame = draw_pitch(CONFIG)
-    
+
     # Draw ball trail with fading effect
     if ball_path is not None and len(ball_path) > 0:
         valid_path = [coords for coords in ball_path if len(coords) > 0]
@@ -474,47 +542,52 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
                 alpha = (i + 1) / min(20, len(valid_path))
                 color = sv.Color(int(255 * alpha), int(255 * alpha), int(255 * alpha))
                 annotated_frame = draw_points_on_pitch(
-                    CONFIG, coords, 
-                    face_color=color, 
-                    edge_color=sv.Color.BLACK, 
+                    CONFIG,
+                    coords,
+                    face_color=color,
+                    edge_color=sv.Color.BLACK,
                     radius=int(6 + alpha * 4),
-                    pitch=annotated_frame
+                    pitch=annotated_frame,
                 )
-    
+
     # Draw current ball position
     if len(pitch_ball_xy) > 0:
         annotated_frame = draw_points_on_pitch(
-            CONFIG, pitch_ball_xy, 
-            face_color=sv.Color.WHITE, 
-            edge_color=sv.Color.BLACK, 
-            radius=10, 
-            pitch=annotated_frame
+            CONFIG,
+            pitch_ball_xy,
+            face_color=sv.Color.WHITE,
+            edge_color=sv.Color.BLACK,
+            radius=10,
+            pitch=annotated_frame,
         )
-    
+
     # Draw players
     for team_id, color_hex in zip([0, 1], ["00BFFF", "FF1493"]):
         mask = players_class_id == team_id
         if np.any(mask):
             annotated_frame = draw_points_on_pitch(
-                CONFIG, pitch_players_xy[mask], 
-                face_color=sv.Color.from_hex(color_hex), 
-                edge_color=sv.Color.BLACK, 
-                radius=16, 
-                pitch=annotated_frame
+                CONFIG,
+                pitch_players_xy[mask],
+                face_color=sv.Color.from_hex(color_hex),
+                edge_color=sv.Color.BLACK,
+                radius=16,
+                pitch=annotated_frame,
             )
-    
+
     # Draw referees
     if len(pitch_referees_xy) > 0:
         annotated_frame = draw_points_on_pitch(
-            CONFIG, pitch_referees_xy, 
-            face_color=sv.Color.from_hex("FFD700"), 
-            edge_color=sv.Color.BLACK, 
-            radius=16, 
-            pitch=annotated_frame
+            CONFIG,
+            pitch_referees_xy,
+            face_color=sv.Color.from_hex("FFD700"),
+            edge_color=sv.Color.BLACK,
+            radius=16,
+            pitch=annotated_frame,
         )
-    
+
     return annotated_frame
 
+
 # ==============================================
 # MAIN ANALYSIS PIPELINE
 # ==============================================
@@ -530,9 +603,17 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
     - Simple events + possession + per-player stats
     """
     if not video_path:
-        return (None, None, None, None, None,
-                "❌ Please upload a video file.",
-                [], [], None)
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            "❌ Please upload a video file.",
+            [],
+            [],
+            None,
+        )
 
     try:
         progress(0, desc="🔧 Initializing...")
@@ -540,15 +621,23 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         # IDs from Roboflow model
         BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
         STRIDE = 30  # Frame sampling for training
-        MAXLEN = 5   # Transformation matrix smoothing
+        MAXLEN = 5  # Transformation matrix smoothing
         MAX_DISTANCE_THRESHOLD = 500  # Ball path outlier threshold
 
         # Video setup
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
-            return (None, None, None, None, None,
-                    f"❌ Failed to open video: {video_path}",
-                    [], [], None)
+            return (
+                None,
+                None,
+                None,
+                None,
+                None,
+                f"❌ Failed to open video: {video_path}",
+                [],
+                [],
+                None,
+            )
 
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
@@ -569,10 +658,10 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         performance_tracker = PlayerPerformanceTracker(CONFIG, fps=fps)
 
         # Simple possession / events stats
-        distance_covered_m = defaultdict(float)        # tid -> meters (for overlay if needed)
-        possession_time_player = defaultdict(float)    # tid -> seconds
-        possession_time_team = defaultdict(float)      # team_id -> seconds
-        team_of_player = {}                            # tid -> team_id
+        distance_covered_m = defaultdict(float)  # tid -> meters
+        possession_time_player = defaultdict(float)  # tid -> seconds
+        possession_time_team = defaultdict(float)  # team_id -> seconds
+        team_of_player = {}  # tid -> team_id
         events: List[Dict] = []
 
         prev_owner_tid: Optional[int] = None
@@ -580,19 +669,19 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 
         # Annotators
         ellipse_annotator = sv.EllipseAnnotator(
-            color=sv.ColorPalette.from_hex(['#00BFFF', '#FF1493', '#FFD700']), 
-            thickness=2
+            color=sv.ColorPalette.from_hex(["#00BFFF", "#FF1493", "#FFD700"]),
+            thickness=2,
         )
         label_annotator = sv.LabelAnnotator(
-            color=sv.ColorPalette.from_hex(['#00BFFF', '#FF1493', '#FFD700']),
-            text_color=sv.Color.from_hex('#FFFFFF'), 
+            color=sv.ColorPalette.from_hex(["#00BFFF", "#FF1493", "#FFD700"]),
+            text_color=sv.Color.from_hex("#FFFFFF"),
             text_thickness=2,
-            text_position=sv.Position.BOTTOM_CENTER
+            text_position=sv.Position.BOTTOM_CENTER,
         )
         triangle_annotator = sv.TriangleAnnotator(
-            color=sv.Color.from_hex('#FFD700'), 
-            base=20, 
-            height=17
+            color=sv.Color.from_hex("#FFD700"),
+            base=20,
+            height=17,
         )
 
         # ByteTrack tracker with optimized settings
@@ -600,7 +689,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             track_activation_threshold=0.4,
             lost_track_buffer=60,
             minimum_matching_threshold=0.85,
-            frame_rate=fps
+            frame_rate=fps,
         )
         tracker.reset()
 
@@ -632,7 +721,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         progress(0.05, desc="🏃 Collecting player samples (Step 1/6)...")
         player_crops = []
         frame_count = 0
-        
+
         while frame_count < min(total_frames, 300):
             ret, frame = cap.read()
             if not ret:
@@ -652,9 +741,17 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         if len(player_crops) == 0:
             cap.release()
             out.release()
-            return (None, None, None, None, None,
-                    "❌ No player crops collected.",
-                    [], [], None)
+            return (
+                None,
+                None,
+                None,
+                None,
+                None,
+                "❌ No player crops collected.",
+                [],
+                [],
+                None,
+            )
 
         print(f"✅ Collected {len(player_crops)} player samples")
 
@@ -673,7 +770,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         frame_count = 0
 
         progress(0.2, desc="🎬 Processing video frames (Step 3/6)...")
-        
+
         frame_idx = 0
         while True:
             ret, frame = cap.read()
@@ -684,10 +781,12 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             t = frame_idx * dt
             frame_count += 1
             tracking_manager.reset_frame()
-            
+
             if frame_count % 30 == 0:
-                progress(0.2 + 0.4 * (frame_count / total_frames), 
-                        desc=f"🎬 Processing frame {frame_count}/{total_frames}")
+                progress(
+                    0.2 + 0.4 * (frame_count / max(total_frames, 1)),
+                    desc=f"🎬 Processing frame {frame_count}/{total_frames}",
+                )
 
             # Player and ball detection
             _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
@@ -700,10 +799,10 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             # Separate ball from other detections
             ball_detections = detections[detections.class_id == BALL_ID]
             ball_detections.xyxy = sv.pad_boxes(xyxy=ball_detections.xyxy, px=10)
-            
+
             all_detections = detections[detections.class_id != BALL_ID]
             all_detections = all_detections.with_nms(threshold=0.5, class_agnostic=True)
-            
+
             # Track detections
             all_detections = tracker.update_with_detections(detections=all_detections)
 
@@ -716,29 +815,31 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             if len(players_detections.xyxy) > 0:
                 crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
                 predicted_teams = team_classifier.predict(crops)
-                
+
                 # Apply stable team assignment
                 for idx, tracker_id in enumerate(players_detections.tracker_id):
                     tracking_manager.update_team_assignment(int(tracker_id), int(predicted_teams[idx]))
                     predicted_teams[idx] = tracking_manager.get_stable_team_id(
-                        int(tracker_id), int(predicted_teams[idx])
+                        int(tracker_id),
+                        int(predicted_teams[idx]),
                     )
-                
+
                 players_detections.class_id = predicted_teams
 
             # Assign goalkeeper teams
             goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
-                players_detections, goalkeepers_detections
+                players_detections,
+                goalkeepers_detections,
             )
 
             # Adjust referee class_id
             referees_detections.class_id -= 1
 
             # Merge all detections
-            all_detections = sv.Detections.merge([
-                players_detections, goalkeepers_detections, referees_detections
-            ])
-            
+            all_detections = sv.Detections.merge(
+                [players_detections, goalkeepers_detections, referees_detections]
+            )
+
             all_detections.class_id = all_detections.class_id.astype(int)
 
             # ========================================
@@ -752,48 +853,66 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             try:
                 result_field, _ = infer_with_confidence(FIELD_DETECTION_MODEL_ID, frame, 0.3)
                 key_points = sv.KeyPoints.from_inference(result_field)
-                
+
                 # Filter confident keypoints
                 filter_mask = key_points.confidence[0] > 0.5
                 frame_ref_pts = key_points.xy[0][filter_mask]
                 pitch_ref_pts = np.array(CONFIG.vertices)[filter_mask]
-                
+
                 if len(frame_ref_pts) >= 4:  # Need at least 4 points for homography
                     transformer = ViewTransformer(source=frame_ref_pts, target=pitch_ref_pts)
                     M.append(transformer.m)
                     transformer.m = np.mean(np.array(M), axis=0)
 
                     # Transform ball position
-                    frame_ball_xy = ball_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-                    pitch_ball_xy = transformer.transform_points(frame_ball_xy) if len(frame_ball_xy) > 0 else np.empty((0, 2))
+                    frame_ball_xy = ball_detections.get_anchors_coordinates(
+                        sv.Position.BOTTOM_CENTER
+                    )
+                    pitch_ball_xy = (
+                        transformer.transform_points(frame_ball_xy)
+                        if len(frame_ball_xy) > 0
+                        else np.empty((0, 2))
+                    )
                     if len(pitch_ball_xy) > 0:
                         frame_ball_pos_pitch = pitch_ball_xy[0]
                     ball_path_raw.append(pitch_ball_xy)
 
                     # Transform all players (including goalkeepers)
                     all_players = sv.Detections.merge([players_detections, goalkeepers_detections])
-                    players_xy = all_players.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-                    pitch_players_xy = transformer.transform_points(players_xy) if len(players_xy) > 0 else np.empty((0, 2))
-                    
+                    players_xy = all_players.get_anchors_coordinates(
+                        sv.Position.BOTTOM_CENTER
+                    )
+                    pitch_players_xy = (
+                        transformer.transform_points(players_xy)
+                        if len(players_xy) > 0
+                        else np.empty((0, 2))
+                    )
+
                     # Transform referees
-                    referees_xy = referees_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-                    pitch_referees_xy = transformer.transform_points(referees_xy) if len(referees_xy) > 0 else np.empty((0, 2))
-                    
+                    referees_xy = referees_detections.get_anchors_coordinates(
+                        sv.Position.BOTTOM_CENTER
+                    )
+                    pitch_referees_xy = (
+                        transformer.transform_points(referees_xy)
+                        if len(referees_xy) > 0
+                        else np.empty((0, 2))
+                    )
+
                     # Store for radar view
                     last_pitch_players_xy = pitch_players_xy
                     last_players_class_id = all_players.class_id
                     last_pitch_referees_xy = pitch_referees_xy
-                    
+
                     # Update performance tracker + distance per player (meters)
                     for idx, tracker_id in enumerate(all_players.tracker_id):
                         tid_int = int(tracker_id)
                         if idx < len(pitch_players_xy):
                             pos_pitch = pitch_players_xy[idx]
                             performance_tracker.update(
-                                tid_int, 
-                                pos_pitch, 
+                                tid_int,
+                                pos_pitch,
                                 int(all_players.class_id[idx]),
-                                frame_count
+                                frame_count,
                             )
                             team_of_player[tid_int] = int(all_players.class_id[idx])
 
@@ -877,7 +996,10 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                                     "from_tid": int(prev_owner_tid),
                                     "to_tid": int(owner_tid),
                                     "team_id": int(cur_team),
-                                    "extra": {"player_distance_m": d_pp, "ball_travel_m": travel_m},
+                                    "extra": {
+                                        "player_distance_m": d_pp,
+                                        "ball_travel_m": travel_m,
+                                    },
                                 },
                                 f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}",
                             )
@@ -889,12 +1011,14 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                         {
                             "type": "possession_change",
                             "t": float(t),
-                            "from_tid": int(prev_owner_tid) if prev_owner_tid is not None else None,
+                            "from_tid": int(prev_owner_tid)
+                            if prev_owner_tid is not None
+                            else None,
                             "to_tid": int(owner_tid),
                             "team_id": int(team_id) if team_id is not None else None,
                             "extra": {},
                         },
-                        ""  # no extra banner for generic changes
+                        "",
                     )
 
             # shot / clearance based on ball speed & direction
@@ -903,7 +1027,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 and frame_ball_pos_pitch is not None
                 and owner_tid is not None
             ):
-                v_vec = (frame_ball_pos_pitch - prev_ball_pos_pitch)  # pitch units
+                v_vec = frame_ball_pos_pitch - prev_ball_pos_pitch  # pitch units
                 # convert to meters per second
                 dist_m = pitch_distance_m(prev_ball_pos_pitch, frame_ball_pos_pitch)
                 speed_mps = dist_m / dt
@@ -960,7 +1084,11 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 labels.append(f"#{int(tid)} T{int(cid)}")
 
             annotated_frame = ellipse_annotator.annotate(annotated_frame, all_detections)
-            annotated_frame = label_annotator.annotate(annotated_frame, all_detections, labels=labels)
+            annotated_frame = label_annotator.annotate(
+                annotated_frame,
+                all_detections,
+                labels=labels,
+            )
             annotated_frame = triangle_annotator.annotate(annotated_frame, ball_detections)
 
             # HUD: possession per team
@@ -968,7 +1096,10 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             team0_pct = 100.0 * possession_time_team.get(0, 0.0) / total_poss
             team1_pct = 100.0 * possession_time_team.get(1, 0.0) / total_poss
 
-            hud_text = f"Team 0 Ball Control: {team0_pct:5.2f}%   Team 1 Ball Control: {team1_pct:5.2f}%"
+            hud_text = (
+                f"Team 0 Ball Control: {team0_pct:5.2f}%   "
+                f"Team 1 Ball Control: {team1_pct:5.2f}%"
+            )
             cv2.rectangle(
                 annotated_frame,
                 (20, annotated_frame.shape[0] - 60),
@@ -994,7 +1125,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                     (20, 20),
                     (annotated_frame.shape[1] - 20, 90),
                     (255, 255, 255),
-                    -1
+                    -1,
                 )
                 cv2.putText(
                     annotated_frame,
@@ -1018,7 +1149,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         # STEP 5: Clean Ball Path (Remove Outliers)
         # ========================================
         progress(0.65, desc="🧹 Cleaning ball trajectory (Step 4/6)...")
-        
+
         # Convert to proper format for cleaning
         path_for_cleaning = []
         for coords in ball_path_raw:
@@ -1029,58 +1160,66 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 path_for_cleaning.append(np.empty((0, 2), dtype=np.float32))
             else:
                 path_for_cleaning.append(coords)
-        
+
         # Remove outliers
         cleaned_path = replace_outliers_based_on_distance(
-            [np.array(p).reshape(-1, 2) if len(p) > 0 else np.empty((0, 2)) for p in path_for_cleaning],
-            MAX_DISTANCE_THRESHOLD
+            [
+                np.array(p).reshape(-1, 2) if len(p) > 0 else np.empty((0, 2))
+                for p in path_for_cleaning
+            ],
+            MAX_DISTANCE_THRESHOLD,
+        )
+
+        print(
+            f"✅ Ball path cleaned: "
+            f"{len([p for p in cleaned_path if len(p) > 0])} valid points"
         )
-        
-        print(f"✅ Ball path cleaned: {len([p for p in cleaned_path if len(p) > 0])} valid points")
 
         # ========================================
         # STEP 6: Generate Performance Analytics
         # ========================================
         progress(0.75, desc="📊 Generating performance analytics (Step 5/6)...")
-        
+
         # Team comparison charts
         comparison_fig = create_team_comparison_plot(performance_tracker)
-        
+
         # Combined team heatmaps
         team_heatmaps_path = "/tmp/team_heatmaps.png"
         team_heatmaps = create_combined_heatmaps(performance_tracker)
         cv2.imwrite(team_heatmaps_path, team_heatmaps)
-        
+
         # Individual player heatmaps (top 6 by distance)
         progress(0.85, desc="🗺️ Creating individual heatmaps...")
         teams = performance_tracker.get_all_players_by_team()
         top_players = []
-        
+
         for team_id in [0, 1]:
             if team_id in teams:
                 team_players = teams[team_id]
-                player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance_meters']) 
-                                  for pid in team_players]
+                player_distances = [
+                    (pid, performance_tracker.get_player_stats(pid)["total_distance_meters"])
+                    for pid in team_players
+                ]
                 player_distances.sort(key=lambda x: x[1], reverse=True)
                 top_players.extend([pid for pid, _ in player_distances[:3]])
-        
+
         individual_heatmaps = []
         for pid in top_players[:6]:
             heatmap = create_player_heatmap_visualization(performance_tracker, pid)
             individual_heatmaps.append(heatmap)
-        
+
         # Arrange individual heatmaps in grid (3 columns)
         if len(individual_heatmaps) > 0:
             rows = []
             for i in range(0, len(individual_heatmaps), 3):
-                row_maps = individual_heatmaps[i:i+3]
+                row_maps = individual_heatmaps[i : i + 3]
                 if len(row_maps) == 3:
                     rows.append(np.hstack(row_maps))
                 elif len(row_maps) == 2:
                     rows.append(np.hstack([row_maps[0], row_maps[1]]))
                 else:
                     rows.append(row_maps[0])
-            
+
             individual_grid = np.vstack(rows) if len(rows) > 1 else rows[0]
             individual_heatmaps_path = "/tmp/individual_heatmaps.png"
             cv2.imwrite(individual_heatmaps_path, individual_grid)
@@ -1095,11 +1234,13 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         try:
             if last_pitch_players_xy is not None:
                 radar_frame = create_game_style_radar(
-                    pitch_ball_xy=cleaned_path[-1] if cleaned_path else np.empty((0, 2)),
+                    pitch_ball_xy=cleaned_path[-1]
+                    if cleaned_path
+                    else np.empty((0, 2)),
                     pitch_players_xy=last_pitch_players_xy,
                     players_class_id=last_players_class_id,
                     pitch_referees_xy=last_pitch_referees_xy,
-                    ball_path=cleaned_path
+                    ball_path=cleaned_path,
                 )
                 cv2.imwrite(radar_path, radar_frame)
             else:
@@ -1122,14 +1263,14 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 
                 row = [
                     int(pid),
-                    int(stats['team_id']),
-                    float(stats['total_distance_meters']),
-                    float(stats['avg_velocity']),
-                    float(stats['max_velocity']),
-                    int(stats['frames_visible']),
-                    int(stats['time_in_defensive_third']),
-                    int(stats['time_in_middle_third']),
-                    int(stats['time_in_attacking_third']),
+                    int(stats["team_id"]),
+                    float(stats["total_distance_meters"]),
+                    float(stats["avg_velocity"]),
+                    float(stats["max_velocity"]),
+                    int(stats["frames_visible"]),
+                    int(stats["time_in_defensive_third"]),
+                    int(stats["time_in_middle_third"]),
+                    int(stats["time_in_attacking_third"]),
                     poss_s,
                     poss_pct,
                 ]
@@ -1151,11 +1292,19 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             if ev_type == "pass":
                 desc = f"Pass #{from_tid} → #{to_tid} (Team {team_id})"
             elif ev_type == "tackle":
-                desc = f"Tackle: #{to_tid} wins ball from #{from_tid} (Team {team_id})"
+                desc = (
+                    f"Tackle: #{to_tid} wins ball from #{from_tid} "
+                    f"(Team {team_id})"
+                )
             elif ev_type == "interception":
-                desc = f"Interception: #{to_tid} intercepts #{from_tid} (Team {team_id})"
+                desc = (
+                    f"Interception: #{to_tid} intercepts #{from_tid} "
+                    f"(Team {team_id})"
+                )
             elif ev_type == "shot":
-                desc = f"Shot by #{from_tid} (Team {team_id}) at {speed_kmh:.1f} km/h"
+                desc = (
+                    f"Shot by #{from_tid} (Team {team_id}) at {speed_kmh:.1f} km/h"
+                )
             elif ev_type == "clearance":
                 desc = f"Clearance by #{from_tid} (Team {team_id})"
             else:
@@ -1184,32 +1333,41 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         progress(0.95, desc="📝 Generating summary report...")
 
         summary_lines = ["✅ **Analysis Complete!**\n"]
-        summary_lines.append(f"**Video Statistics:**")
+        summary_lines.append("**Video Statistics:**")
         summary_lines.append(f"- Total Frames Processed: {frame_count}")
         summary_lines.append(f"- Video Resolution: {width}x{height}")
         summary_lines.append(f"- Frame Rate: {fps:.2f} fps")
-        summary_lines.append(f"- Ball Trajectory Points: {len([p for p in cleaned_path if len(p) > 0])}\n")
-        
+        summary_lines.append(
+            f"- Ball Trajectory Points: "
+            f"{len([p for p in cleaned_path if len(p) > 0])}\n"
+        )
+
         for team_id in [0, 1]:
             if team_id not in teams:
                 continue
-            
+
             team_name = "Team 0 (Blue)" if team_id == 0 else "Team 1 (Pink)"
             summary_lines.append(f"\n**{team_name}:**")
             summary_lines.append(f"- Players Tracked: {len(teams[team_id])}")
-            
-            total_dist = sum(performance_tracker.get_player_stats(pid)['total_distance_meters'] 
-                           for pid in teams[team_id])
+
+            total_dist = sum(
+                performance_tracker.get_player_stats(pid)["total_distance_meters"]
+                for pid in teams[team_id]
+            )
             avg_dist = total_dist / len(teams[team_id]) if len(teams[team_id]) > 0 else 0
             summary_lines.append(f"- Team Total Distance: {total_dist:.1f} m")
-            summary_lines.append(f"- Average Distance per Player: {avg_dist:.1f} m")
-            
+            summary_lines.append(
+                f"- Average Distance per Player: {avg_dist:.1f} m"
+            )
+
             # Top 3 performers (by distance)
-            player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance_meters']) 
-                              for pid in teams[team_id]]
+            player_distances = [
+                (pid, performance_tracker.get_player_stats(pid)["total_distance_meters"])
+                for pid in teams[team_id]
+            ]
             player_distances.sort(key=lambda x: x[1], reverse=True)
-            
-            summary_lines.append(f"\n  **Top 3 Performers:**")
+
+            summary_lines.append("\n  **Top 3 Performers:**")
             for i, (pid, dist) in enumerate(player_distances[:3], 1):
                 stats = performance_tracker.get_player_stats(pid)
                 summary_lines.append(
@@ -1223,10 +1381,8 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         for team_id in sorted(possession_time_team.keys()):
             t_sec = possession_time_team[team_id]
             pct = 100.0 * t_sec / total_poss if total_poss > 0 else 0.0
-            summary_lines.append(
-                f"- Team {team_id}: {t_sec:.1f} s ({pct:.1f}%)"
-            )
-        
+            summary_lines.append(f"- Team {team_id}: {t_sec:.1f} s ({pct:.1f}%)")
+
         summary_lines.append("\n**Pipeline Steps Completed:**")
         summary_lines.append("✅ 1. Player crop collection")
         summary_lines.append("✅ 2. Team classifier training")
@@ -1234,41 +1390,96 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         summary_lines.append("✅ 4. Ball trajectory cleaning")
         summary_lines.append("✅ 5. Performance analytics generation")
         summary_lines.append("✅ 6. Visualization creation")
-        
+
         summary_msg = "\n".join(summary_lines)
 
         progress(1.0, desc="✅ Analysis Complete!")
 
         # IMPORTANT: must return 9 outputs in the same order as Gradio wiring
         return (
-            output_path,            # video_output
-            comparison_fig,         # comparison_output
-            team_heatmaps_path,     # team_heatmaps_output
+            output_path,  # video_output
+            comparison_fig,  # comparison_output
+            team_heatmaps_path,  # team_heatmaps_output
             individual_heatmaps_path,  # individual_heatmaps_output
-            radar_path,             # radar_output
-            summary_msg,            # status_output
-            player_stats_table,     # player_stats_output (Dataframe)
-            events_table,           # events_output (Dataframe)
-            events_json_path,       # events_json_output (File download)
+            radar_path,  # radar_output
+            summary_msg,  # status_output
+            player_stats_table,  # player_stats_output (Dataframe)
+            events_table,  # events_output (Dataframe)
+            events_json_path,  # events_json_output (File download)
         )
 
     except Exception as e:
         error_msg = f"❌ Error: {str(e)}"
         print(error_msg)
         import traceback
+
         traceback.print_exc()
         # Match the 9 outputs (fill with Nones/empties)
         return (
-            None, None, None, None, None,
+            None,
+            None,
+            None,
+            None,
+            None,
             error_msg,
-            [], [], None
+            [],
+            [],
+            None,
         )
 
+
 # ==============================================
 # GRADIO INTERFACE
 # ==============================================
+
+def run_pipeline(video) -> Tuple:
+    """
+    Gradio wrapper: accept the raw video object from gr.Video and
+    convert it to a filesystem path for analyze_football_video().
+    """
+    if video is None:
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            "❌ Please upload a video file.",
+            [],
+            [],
+            None,
+        )
+
+    # On Spaces, Video input is usually a dict with at least a "path" key.
+    if isinstance(video, dict):
+        video_path = (
+            video.get("path")
+            or video.get("name")
+            or video.get("filename")
+        )
+    else:
+        # Fallback: if it's already a string/path-like
+        video_path = str(video)
+
+    if not video_path:
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            "❌ Could not resolve video file path from upload.",
+            [],
+            [],
+            None,
+        )
+
+    return analyze_football_video(video_path)
+
+
 with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) as iface:
-    gr.Markdown("""
+    gr.Markdown(
+        """
     # ⚽ Advanced Football Video Analyzer
     ### Complete Pipeline Implementation
     
@@ -1281,34 +1492,37 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
     6. **Performance Analytics** - Heatmaps, stats, possession, and event detection  
     
     Upload a football match video to get comprehensive performance analytics!
-    """)
-    
-     with gr.Row():
-        # No "type" argument here – Gradio's Video in your Space does not support it
+    """
+    )
+
+    with gr.Row():
+        # No "type" argument – your Gradio version does not support it
         video_input = gr.Video(label="📤 Upload Football Video")
-    
+
     analyze_btn = gr.Button("🚀 Start Analysis Pipeline", variant="primary", size="lg")
-    
+
     with gr.Row():
         status_output = gr.Textbox(label="📊 Analysis Summary & Statistics", lines=25)
-    
+
     with gr.Tabs():
         with gr.Tab("📹 Annotated Video"):
-            gr.Markdown("### Full video with player tracking, team colors, ball detection, and events overlay")
+            gr.Markdown(
+                "### Full video with player tracking, team colors, ball detection, and events overlay"
+            )
             video_output = gr.Video(label="Processed Video")
-        
+
         with gr.Tab("📊 Performance Comparison"):
             gr.Markdown("### Interactive charts comparing player performance metrics")
             comparison_output = gr.Plot(label="Team Performance Metrics")
-        
+
         with gr.Tab("🗺️ Team Heatmaps"):
             gr.Markdown("### Combined activity heatmaps showing team positioning")
             team_heatmaps_output = gr.Image(label="Team Activity Heatmaps")
-        
+
         with gr.Tab("👤 Individual Heatmaps"):
             gr.Markdown("### Top 6 players with detailed activity analysis")
             individual_heatmaps_output = gr.Image(label="Top Players Heatmaps")
-        
+
         with gr.Tab("🎮 Game Radar View"):
             gr.Markdown("### Game-style tactical view with ball trail")
             radar_output = gr.Image(label="Tactical Radar View")
@@ -1317,41 +1531,44 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
             gr.Markdown("### Per-player totals: distance, speeds, zones, possession")
             player_stats_output = gr.Dataframe(
                 headers=PLAYER_STATS_HEADERS,
-                col_count=len(PLAYER_STATS_HEADERS),   # IMPORTANT: must equal headers length
+                col_count=len(PLAYER_STATS_HEADERS),
                 row_count=0,
-                interactive=False
+                interactive=False,
             )
 
         with gr.Tab("⏱️ Event Timeline"):
-            gr.Markdown("### Detected passes, tackles, interceptions, shots, clearances")
+            gr.Markdown(
+                "### Detected passes, tackles, interceptions, shots, clearances"
+            )
             events_output = gr.Dataframe(
                 headers=EVENT_HEADERS,
-                col_count=len(EVENT_HEADERS),          # IMPORTANT: must equal headers length
+                col_count=len(EVENT_HEADERS),
                 row_count=0,
-                interactive=False
+                interactive=False,
             )
             events_json_output = gr.File(
                 label="Download events JSON",
-                file_types=[".json"]
+                file_types=[".json"],
             )
-    
+
     analyze_btn.click(
-        fn=analyze_football_video,
+        fn=run_pipeline,
         inputs=[video_input],
         outputs=[
-            video_output,          # 1
-            comparison_output,     # 2
+            video_output,  # 1
+            comparison_output,  # 2
             team_heatmaps_output,  # 3
             individual_heatmaps_output,  # 4
-            radar_output,          # 5
-            status_output,         # 6
-            player_stats_output,   # 7
-            events_output,         # 8
-            events_json_output,    # 9
-        ]
+            radar_output,  # 5
+            status_output,  # 6
+            player_stats_output,  # 7
+            events_output,  # 8
+            events_json_output,  # 9
+        ],
     )
-    
-    gr.Markdown("""
+
+    gr.Markdown(
+        """
     ---
     ### 🔧 Technical Details:
     
@@ -1380,7 +1597,9 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
     - Passes, tackles, interceptions, shots, clearances  
     - Event banner overlay in video  
     - Full event list downloadable as JSON  
-    """)
+    """
+    )
+
 
 if __name__ == "__main__":
-    iface.launch(share=True)
+    iface.launch()