Capstone - Complete Analytics System

# Python: Video-data integration framework
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from datetime import timedelta
import pandas as pd

@dataclass
class VideoClip:
    """Represents a single video clip linked to event data."""
    clip_id: str
    match_id: str
    start_time: float  # seconds from match start
    end_time: float
    event_type: Optional[str] = None
    player: Optional[str] = None
    tags: List[str] = field(default_factory=list)
    video_path: Optional[str] = None
    thumbnail_path: Optional[str] = None

    def format_timestamp(self) -> str:
        """Format start time as MM:SS."""
        minutes = int(self.start_time // 60)
        seconds = int(self.start_time % 60)
        return f"{minutes:02d}:{seconds:02d}"

    @property
    def duration(self) -> float:
        """Calculate clip duration in seconds."""
        return self.end_time - self.start_time

    def add_tag(self, tag: str):
        """Add a tag to the clip."""
        if tag not in self.tags:
            self.tags.append(tag)

    def to_dict(self) -> Dict:
        """Convert to dictionary."""
        return {
            "clip_id": self.clip_id,
            "match_id": self.match_id,
            "timestamp": self.format_timestamp(),
            "duration": self.duration,
            "event_type": self.event_type,
            "player": self.player,
            "tags": self.tags
        }

class VideoLibrary:
    """Manages video clips and provides search functionality."""

    def __init__(self):
        self.clips: Dict[str, VideoClip] = {}
        self.matches: pd.DataFrame = pd.DataFrame()

    def add_clip(self, clip: VideoClip):
        """Add a clip to the library."""
        self.clips[clip.clip_id] = clip

    def search_by_tags(self, tags: List[str],
                       match_all: bool = False) -> List[VideoClip]:
        """Search clips by tags."""
        results = []
        for clip in self.clips.values():
            if match_all:
                if all(tag in clip.tags for tag in tags):
                    results.append(clip)
            else:
                if any(tag in clip.tags for tag in tags):
                    results.append(clip)
        return results

    def get_player_clips(self, player_name: str,
                         event_type: Optional[str] = None) -> List[VideoClip]:
        """Get all clips for a specific player."""
        results = []
        for clip in self.clips.values():
            if clip.player == player_name:
                if event_type is None or clip.event_type == event_type:
                    results.append(clip)
        return results

    def get_match_clips(self, match_id: str) -> List[VideoClip]:
        """Get all clips from a specific match."""
        return [c for c in self.clips.values() if c.match_id == match_id]

    def to_dataframe(self) -> pd.DataFrame:
        """Convert library to DataFrame."""
        return pd.DataFrame([c.to_dict() for c in self.clips.values()])

# Initialize library
library = VideoLibrary()
print("Video library framework initialized")

# Python: Automated video tagging from event data
import pandas as pd
from typing import List, Dict, Optional
from dataclasses import dataclass

class VideoTagger:
    """Automatically generate video clips from event data."""

    def __init__(self, buffer_before: float = 5.0,
                 buffer_after: float = 3.0):
        self.buffer_before = buffer_before
        self.buffer_after = buffer_after

    def events_to_clips(self, events_df: pd.DataFrame,
                        match_id: str) -> List[VideoClip]:
        """Convert event data to video clips."""
        clips = []

        for _, event in events_df.iterrows():
            # Calculate event time in seconds
            event_seconds = event["minute"] * 60 + event.get("second", 0)

            # Create clip
            clip = VideoClip(
                clip_id=f"{match_id}_{event['event_id']}",
                match_id=match_id,
                start_time=max(0, event_seconds - self.buffer_before),
                end_time=event_seconds + self.buffer_after,
                event_type=event.get("type"),
                player=event.get("player"),
                tags=self._generate_auto_tags(event)
            )

            clips.append(clip)

        return clips

    def _generate_auto_tags(self, event: pd.Series) -> List[str]:
        """Generate automatic tags based on event properties."""
        tags = []

        # Event type
        if pd.notna(event.get("type")):
            tags.append(event["type"])

        # Outcome
        if pd.notna(event.get("outcome")):
            tags.append(event["outcome"])

        # Location zone
        if pd.notna(event.get("x")) and pd.notna(event.get("y")):
            zone = self._classify_pitch_zone(event["x"], event["y"])
            tags.append(zone)

        # Pressure
        if event.get("under_pressure", False):
            tags.append("under_pressure")

        # Body part
        if pd.notna(event.get("body_part")):
            tags.append(event["body_part"])

        # xG classification for shots
        if event.get("type") == "Shot" and pd.notna(event.get("xg")):
            xg = event["xg"]
            if xg >= 0.3:
                tags.append("big_chance")
            elif xg >= 0.1:
                tags.append("good_chance")
            else:
                tags.append("low_xg_shot")

        return list(set(tags))

    def _classify_pitch_zone(self, x: float, y: float) -> str:
        """Classify location into pitch zone."""
        # Assuming 120x80 pitch
        if x >= 102:
            zone = "box"
        elif x >= 80:
            zone = "final_third"
        elif x >= 40:
            zone = "middle_third"
        else:
            zone = "defensive_third"

        if y <= 26:
            side = "left"
        elif y >= 54:
            side = "right"
        else:
            side = "central"

        return f"{zone}_{side}"

# Extended tagging for specific analysis types
class AnalysisSpecificTagger(VideoTagger):
    """Extended tagger for specific analysis needs."""

    def tag_pressing_events(self, events_df: pd.DataFrame,
                            match_id: str) -> List[VideoClip]:
        """Tag pressing and counterpressing events."""
        pressing_events = events_df[
            events_df["type"].isin(["Pressure", "Ball Recovery", "Tackle"])
        ]

        clips = self.events_to_clips(pressing_events, match_id)

        # Add pressing-specific tags
        for clip in clips:
            clip.add_tag("pressing_analysis")
            # Check if counterpress (within 5 sec of losing ball)
            # Would need possession change data

        return clips

    def tag_set_pieces(self, events_df: pd.DataFrame,
                       match_id: str) -> List[VideoClip]:
        """Tag set piece events with extended context."""
        set_pieces = events_df[
            events_df["type"].isin(["Corner", "Free Kick", "Throw-in"])
        ]

        clips = []
        for _, event in set_pieces.iterrows():
            event_seconds = event["minute"] * 60 + event.get("second", 0)

            # Longer buffer for set pieces
            clip = VideoClip(
                clip_id=f"{match_id}_{event['event_id']}_setpiece",
                match_id=match_id,
                start_time=max(0, event_seconds - 3),
                end_time=event_seconds + 15,  # Longer to capture outcome
                event_type=event.get("type"),
                player=event.get("player"),
                tags=["set_piece", event.get("type", "")]
            )
            clips.append(clip)

        return clips

tagger = VideoTagger()
print("Video tagger initialized")

# Python: Create video playlists from data queries
import pandas as pd
from typing import List, Dict, Optional, Callable
from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class VideoPlaylist:
    """Collection of video clips for a specific purpose."""
    name: str
    description: str = ""
    clips: List[VideoClip] = field(default_factory=list)
    created_date: datetime = field(default_factory=datetime.now)

    def add_clip(self, clip: VideoClip):
        """Add a clip to the playlist."""
        self.clips.append(clip)

    def add_clips(self, clips: List[VideoClip]):
        """Add multiple clips."""
        self.clips.extend(clips)

    def sort_chronologically(self):
        """Sort clips by start time."""
        self.clips.sort(key=lambda c: (c.match_id, c.start_time))

    @property
    def total_duration(self) -> float:
        """Total duration of all clips in seconds."""
        return sum(c.duration for c in self.clips)

    @property
    def clip_count(self) -> int:
        """Number of clips in playlist."""
        return len(self.clips)

    def to_dataframe(self) -> pd.DataFrame:
        """Export playlist as DataFrame."""
        return pd.DataFrame([c.to_dict() for c in self.clips])

    def export_for_video_software(self) -> List[Dict]:
        """Export in format for video editing software."""
        return [
            {
                "clip_name": c.clip_id,
                "source_file": c.video_path,
                "in_point": c.start_time,
                "out_point": c.end_time,
                "duration": c.duration,
                "markers": c.tags
            }
            for c in self.clips
        ]

class PlaylistGenerator:
    """Generate playlists from data queries."""

    def __init__(self, library: VideoLibrary):
        self.library = library

    def create_from_query(self, events: pd.DataFrame,
                          name: str,
                          filters: Dict) -> VideoPlaylist:
        """Create playlist from filtered events."""
        playlist = VideoPlaylist(
            name=name,
            description=f"Auto-generated: {datetime.now()}"
        )

        # Apply filters
        filtered = events.copy()

        if "player" in filters and filters["player"]:
            filtered = filtered[filtered["player"] == filters["player"]]

        if "event_types" in filters and filters["event_types"]:
            filtered = filtered[filtered["type"].isin(filters["event_types"])]

        if "min_xg" in filters and filters["min_xg"]:
            filtered = filtered[filtered["xg"] >= filters["min_xg"]]

        if "zone" in filters and filters["zone"]:
            filtered = filtered[filtered["pitch_zone"] == filters["zone"]]

        if "team" in filters and filters["team"]:
            filtered = filtered[filtered["team"] == filters["team"]]

        # Find corresponding clips
        for _, event in filtered.iterrows():
            clip_id = f"{event['match_id']}_{event['event_id']}"
            if clip_id in self.library.clips:
                playlist.add_clip(self.library.clips[clip_id])

        playlist.sort_chronologically()
        return playlist

    def create_scouting_playlist(self, player_name: str,
                                  events: pd.DataFrame) -> VideoPlaylist:
        """Create comprehensive scouting playlist for a player."""
        key_events = ["Shot", "Goal", "Assist", "Key Pass",
                      "Dribble", "Progressive Pass", "Tackle", "Interception"]

        return self.create_from_query(
            events,
            name=f"Scouting: {player_name}",
            filters={
                "player": player_name,
                "event_types": key_events
            }
        )

    def create_big_chances_playlist(self, events: pd.DataFrame,
                                     team: Optional[str] = None) -> VideoPlaylist:
        """Create playlist of big chances (high xG shots)."""
        filters = {
            "event_types": ["Shot"],
            "min_xg": 0.3
        }
        if team:
            filters["team"] = team

        return self.create_from_query(
            events,
            name=f"Big Chances{f' - {team}' if team else ''}",
            filters=filters
        )

    def create_defensive_errors_playlist(self, events: pd.DataFrame,
                                          team: str) -> VideoPlaylist:
        """Create playlist of defensive errors and goals conceded."""
        # Get shots conceded with high xG
        shots_against = events[
            (events["type"] == "Shot") &
            (events["team"] != team) &
            (events["xg"] >= 0.15)
        ]

        playlist = VideoPlaylist(
            name=f"Defensive Review: {team}",
            description="High-quality chances conceded"
        )

        for _, event in shots_against.iterrows():
            clip_id = f"{event['match_id']}_{event['event_id']}"
            if clip_id in self.library.clips:
                playlist.add_clip(self.library.clips[clip_id])

        return playlist

print("Playlist generator ready")

# Python: Integrate video into scouting reports
from typing import Dict, List, Optional
from dataclasses import dataclass, field
import pandas as pd

@dataclass
class InsightWithEvidence:
    """Statistical insight backed by video evidence."""
    category: str
    description: str
    stats: Dict
    clips: List[VideoClip]

class ScoutingReportWithVideo:
    """Scouting report integrating stats and video."""

    def __init__(self, player_name: str, position: str):
        self.player_name = player_name
        self.position = position
        self.insights: List[InsightWithEvidence] = []
        self.summary_clips: List[VideoClip] = []

    def add_insight(self, category: str, description: str,
                    stats: Dict, clips: List[VideoClip]):
        """Add insight with video evidence."""
        self.insights.append(InsightWithEvidence(
            category=category,
            description=description,
            stats=stats,
            clips=clips
        ))

    def generate_report(self) -> str:
        """Generate formatted report."""
        report = f"""
==========================================================
SCOUTING REPORT: {self.player_name} ({self.position})
==========================================================
"""
        for insight in self.insights:
            clip_summary = self._format_clip_list(insight.clips)
            report += f"""
{insight.category.upper()}
{"-" * len(insight.category)}
{insight.description}

Key Statistics:
{self._format_stats(insight.stats)}

Video Evidence ({len(insight.clips)} clips):
{clip_summary}
"""
        return report

    def _format_stats(self, stats: Dict) -> str:
        """Format statistics for display."""
        return "\n".join([f"  {k}: {v}" for k, v in stats.items()])

    def _format_clip_list(self, clips: List[VideoClip], max_clips: int = 5) -> str:
        """Format clip list for display."""
        if not clips:
            return "  No clips available"

        lines = []
        for clip in clips[:max_clips]:
            tags = ", ".join(clip.tags[:3])
            lines.append(f"  - {clip.format_timestamp()}: {clip.event_type} ({tags})")

        if len(clips) > max_clips:
            lines.append(f"  ... and {len(clips) - max_clips} more clips")

        return "\n".join(lines)

    def export_with_clips(self) -> Dict:
        """Export report data with clip references."""
        return {
            "player": self.player_name,
            "position": self.position,
            "insights": [
                {
                    "category": i.category,
                    "description": i.description,
                    "stats": i.stats,
                    "clip_ids": [c.clip_id for c in i.clips]
                }
                for i in self.insights
            ],
            "total_clips": sum(len(i.clips) for i in self.insights)
        }

class ScoutingReportGenerator:
    """Generate scouting reports with video integration."""

    def __init__(self, library: VideoLibrary):
        self.library = library

    def generate_report(self, player_name: str,
                        player_stats: pd.Series,
                        events: pd.DataFrame) -> ScoutingReportWithVideo:
        """Generate comprehensive scouting report."""

        position = player_stats.get("position", "Unknown")
        report = ScoutingReportWithVideo(player_name, position)

        # Finishing analysis (for attackers)
        if any(p in position for p in ["FW", "MF", "AM"]):
            self._add_finishing_insight(report, player_name, player_stats, events)

        # Chance creation
        self._add_creation_insight(report, player_name, player_stats, events)

        # Defensive contribution
        self._add_defensive_insight(report, player_name, player_stats, events)

        # Progression
        self._add_progression_insight(report, player_name, player_stats, events)

        return report

    def _add_finishing_insight(self, report: ScoutingReportWithVideo,
                               player_name: str, stats: pd.Series,
                               events: pd.DataFrame):
        """Add finishing analysis with video."""
        shot_events = events[
            (events["player"] == player_name) &
            (events["type"] == "Shot")
        ]

        clips = self.library.get_player_clips(player_name, "Shot")
        goal_clips = [c for c in clips if "Goal" in c.tags]

        report.add_insight(
            category="Finishing",
            description=f"Shows clinical finishing ability with {len(goal_clips)} goals",
            stats={
                "Goals": len(goal_clips),
                "Total Shots": len(clips),
                "xG": round(stats.get("xg", 0), 2),
                "Conversion Rate": f"{len(goal_clips)/max(1,len(clips))*100:.0f}%"
            },
            clips=clips
        )

    def _add_creation_insight(self, report, player_name, stats, events):
        """Add chance creation analysis."""
        creative_clips = [
            c for c in self.library.get_player_clips(player_name)
            if any(tag in c.tags for tag in ["Key Pass", "Assist", "Shot Assist"])
        ]

        report.add_insight(
            category="Chance Creation",
            description="Creative ability to unlock defenses",
            stats={
                "Assists": int(stats.get("assists", 0)),
                "xA": round(stats.get("xa", 0), 2),
                "Key Passes": len([c for c in creative_clips if "Key Pass" in c.tags])
            },
            clips=creative_clips
        )

    def _add_defensive_insight(self, report, player_name, stats, events):
        """Add defensive contribution analysis."""
        defensive_clips = [
            c for c in self.library.get_player_clips(player_name)
            if any(tag in c.tags for tag in ["Tackle", "Interception", "Block", "Clearance"])
        ]

        report.add_insight(
            category="Defensive Work",
            description="Contribution without the ball",
            stats={
                "Tackles Won": int(stats.get("tackles_won", 0)),
                "Interceptions": int(stats.get("interceptions", 0)),
                "Pressures": int(stats.get("pressures", 0))
            },
            clips=defensive_clips
        )

    def _add_progression_insight(self, report, player_name, stats, events):
        """Add ball progression analysis."""
        progressive_clips = [
            c for c in self.library.get_player_clips(player_name)
            if any(tag in c.tags for tag in ["Progressive Pass", "Progressive Carry", "final_third"])
        ]

        report.add_insight(
            category="Ball Progression",
            description="Ability to advance the ball effectively",
            stats={
                "Progressive Passes": int(stats.get("progressive_passes", 0)),
                "Progressive Carries": int(stats.get("progressive_carries", 0)),
                "Final Third Entries": len([c for c in progressive_clips if "final_third" in c.tags])
            },
            clips=progressive_clips
        )

print("Scouting report generator with video ready")

# Python: Coaching-specific video workflows
from typing import Dict, List
import pandas as pd
from dataclasses import dataclass

@dataclass
class VideoPackage:
    """Collection of themed video content for coaching."""
    title: str
    description: str
    sections: Dict[str, Dict]

class CoachingVideoWorkflows:
    """Video workflows tailored for coaching staff."""

    def __init__(self, library: VideoLibrary):
        self.library = library

    def create_prematch_package(self, opponent: str,
                                 opponent_events: pd.DataFrame) -> VideoPackage:
        """Create pre-match video package for coaches."""

        package = VideoPackage(
            title=f"Pre-Match Analysis: vs {opponent}",
            description="Opponent analysis video package",
            sections={}
        )

        # Attacking threats
        attacking = opponent_events[
            (opponent_events["team"] == opponent) &
            (opponent_events["type"].isin(["Shot", "Key Pass", "Cross"]))
        ]

        matches = opponent_events["match_id"].nunique()
        package.sections["attacking"] = {
            "title": "Attacking Threats",
            "stats": {
                "shots_per_game": len(attacking) / max(1, matches),
                "xg_per_game": attacking["xg"].sum() / max(1, matches)
            },
            "clips": self.library.search_by_tags(["Shot", opponent]),
            "coaching_points": [
                "Watch for runs in behind from #9",
                "Left winger likes to cut inside",
                "Dangerous from set pieces"
            ]
        }

        # Set pieces
        set_pieces = opponent_events[
            (opponent_events["team"] == opponent) &
            (opponent_events["type"].isin(["Corner", "Free Kick"]))
        ]

        package.sections["set_pieces"] = {
            "title": "Set Piece Routines",
            "stats": {
                "corners_per_game": len(set_pieces[set_pieces["type"] == "Corner"]) / max(1, matches)
            },
            "clips": self.library.search_by_tags(["set_piece", opponent]),
            "coaching_points": [
                "Near post corner routine",
                "Short corner option"
            ]
        }

        # Defensive weaknesses
        against = opponent_events[
            (opponent_events["team"] != opponent) &
            (opponent_events["type"] == "Shot")
        ]

        package.sections["weaknesses"] = {
            "title": "Exploitable Weaknesses",
            "stats": {
                "xga_per_game": against["xg"].sum() / max(1, matches)
            },
            "clips": self.library.search_by_tags(["Goal", f"vs_{opponent}"]),
            "coaching_points": [
                "High line vulnerable to balls over the top",
                "Slow transition from attack to defense"
            ]
        }

        return package

    def create_halftime_clips(self, match_events: pd.DataFrame,
                               our_team: str) -> Dict:
        """Generate halftime video clips for tactical adjustments."""

        first_half = match_events[match_events["minute"] <= 45]

        return {
            "our_chances": {
                "title": "Our Best Chances",
                "clips": [
                    c for c in self.library.get_match_clips(match_events["match_id"].iloc[0])
                    if "Shot" in c.tags and c.start_time < 45*60
                ]
            },
            "chances_conceded": {
                "title": "Chances Conceded",
                "clips": [
                    c for c in self.library.get_match_clips(match_events["match_id"].iloc[0])
                    if "Shot" in c.tags and our_team not in str(c.tags) and c.start_time < 45*60
                ]
            },
            "pressing": {
                "title": "Pressing Actions",
                "clips": self.library.search_by_tags(["Pressure", "Ball Recovery"])[:5]
            }
        }

    def create_player_feedback(self, player_name: str,
                                match_id: str,
                                events: pd.DataFrame) -> Dict:
        """Create individual player feedback package."""

        player_events = events[
            (events["match_id"] == match_id) &
            (events["player"] == player_name)
        ]

        player_clips = self.library.get_player_clips(player_name)
        match_clips = [c for c in player_clips if c.match_id == match_id]

        # Categorize clips
        positive_tags = {"Goal", "Assist", "Tackle Won", "Interception", "Success"}
        negative_tags = {"Miss", "Dispossession", "Error", "Lost"}

        return {
            "player": player_name,
            "match_id": match_id,
            "positives": {
                "title": "Excellent Moments",
                "clips": [c for c in match_clips
                         if any(t in positive_tags for t in c.tags)]
            },
            "improvements": {
                "title": "Areas to Work On",
                "clips": [c for c in match_clips
                         if any(t in negative_tags for t in c.tags)]
            },
            "summary": {
                "total_actions": len(player_events),
                "successful": len(player_events[player_events["outcome"] == "Success"]),
                "video_clips": len(match_clips)
            }
        }

    def create_weekly_development_package(self, player_name: str,
                                           events: pd.DataFrame,
                                           focus_area: str) -> Dict:
        """Create weekly development video package for a player."""

        focus_tags = {
            "finishing": ["Shot", "Goal", "big_chance"],
            "passing": ["Progressive Pass", "Key Pass", "Through Ball"],
            "defending": ["Tackle", "Interception", "Block"],
            "dribbling": ["Dribble", "Carry", "Take On"]
        }

        clips = self.library.search_by_tags(focus_tags.get(focus_area, []))
        player_clips = [c for c in clips if c.player == player_name]

        return {
            "player": player_name,
            "focus": focus_area,
            "your_clips": player_clips,
            "example_clips": clips[:10],  # Best examples from anyone
            "drills_focus": f"This week focus on {focus_area}",
            "clip_count": len(player_clips)
        }

print("Coaching video workflows ready")