Capstone - Complete Analytics System

from statsbombpy import sb
import pandas as pd

# Load a match
events = sb.events(match_id=3869685)

# Look at a single pass event in detail
pass_events = events[events['type'] == 'Pass']
sample_pass = pass_events.iloc[0]

print("=== Anatomy of a Pass Event ===\n")

# Core identifiers
print("IDENTIFIERS:")
print(f"  Event ID: {sample_pass['id']}")
print(f"  Match ID: {sample_pass['match_id']}")
print(f"  Index: {sample_pass['index']}")

# Temporal information
print("\nTIMING:")
print(f"  Period: {sample_pass['period']}")
print(f"  Minute: {sample_pass['minute']}")
print(f"  Second: {sample_pass['second']}")
print(f"  Timestamp: {sample_pass['timestamp']}")

# Who and what
print("\nACTION:")
print(f"  Type: {sample_pass['type']}")
print(f"  Player: {sample_pass['player']}")
print(f"  Team: {sample_pass['team']}")
print(f"  Position: {sample_pass['position']}")

# Spatial information
print("\nLOCATION:")
print(f"  Start: {sample_pass['location']}")
print(f"  End: {sample_pass['pass_end_location']}")

# Pass-specific details
print("\nPASS DETAILS:")
print(f"  Recipient: {sample_pass['pass_recipient']}")
print(f"  Length: {sample_pass['pass_length']:.1f}")
print(f"  Angle: {sample_pass['pass_angle']:.2f} radians")
print(f"  Height: {sample_pass['pass_height']}")
print(f"  Body Part: {sample_pass['pass_body_part']}")

import pandas as pd
from statsbombpy import sb

# Load events
events = sb.events(match_id=3869685)

# 1. VIEWING DATA
print("Shape:", events.shape)  # (rows, columns)
print("\nFirst 5 rows:")
print(events.head())

# 2. SELECTING COLUMNS
# Single column
players = events['player']

# Multiple columns
subset = events[['player', 'team', 'type', 'minute']]

# 3. DATA TYPES
print("\nColumn types:")
print(events.dtypes.head(10))

# 4. BASIC STATISTICS
print("\nNumeric column stats:")
print(events[['minute', 'second']].describe())

# 5. UNIQUE VALUES
print("\nUnique event types:")
print(events['type'].unique())

# 6. VALUE COUNTS
print("\nEvent type distribution:")
print(events['type'].value_counts().head(10))

# 7. SORTING
# Sort by minute and second
sorted_events = events.sort_values(['minute', 'second'])

# Sort descending
top_xg_shots = events[events['type'] == 'Shot'].sort_values(
    'shot_statsbomb_xg', ascending=False
).head(5)

import pandas as pd
import numpy as np

def convert_statsbomb_to_opta(x, y):
    """Convert StatsBomb (120x80) to Opta (100x100) coordinates."""
    opta_x = (x / 120) * 100
    opta_y = (y / 80) * 100
    return opta_x, opta_y

def convert_opta_to_statsbomb(x, y):
    """Convert Opta (100x100) to StatsBomb (120x80) coordinates."""
    sb_x = (x / 100) * 120
    sb_y = (y / 100) * 80
    return sb_x, sb_y

def convert_wyscout_to_statsbomb(x, y):
    """Convert Wyscout to StatsBomb (flip Y-axis)."""
    sb_x = (x / 100) * 120
    sb_y = ((100 - y) / 100) * 80  # Flip Y
    return sb_x, sb_y

# Example: Convert a StatsBomb shot location
shot_x, shot_y = 108.0, 36.0  # Near the penalty spot

opta_x, opta_y = convert_statsbomb_to_opta(shot_x, shot_y)
print(f"StatsBomb: ({shot_x}, {shot_y})")
print(f"Opta:      ({opta_x:.1f}, {opta_y:.1f})")

# Convert to meters (standard 105x68 pitch)
meters_x = (shot_x / 120) * 105
meters_y = (shot_y / 80) * 68
print(f"Meters:    ({meters_x:.1f}m, {meters_y:.1f}m)")

# Calculate distance to goal center
goal_x, goal_y = 120, 40  # Goal center in StatsBomb coords
distance = np.sqrt((shot_x - goal_x)**2 + (shot_y - goal_y)**2)
distance_meters = (distance / 120) * 105
print(f"\nDistance to goal: {distance_meters:.1f} meters")

from statsbombpy import sb
import pandas as pd

events = sb.events(match_id=3869685)

# 1. FILTER BY EVENT TYPE
shots = events[events['type'] == 'Shot']
passes = events[events['type'] == 'Pass']
print(f"Shots: {len(shots)}, Passes: {len(passes)}")

# 2. FILTER BY TEAM
argentina_events = events[events['team'] == 'Argentina']
france_events = events[events['team'] == 'France']

# 3. FILTER BY PLAYER
messi_events = events[events['player'] == 'Lionel Andrés Messi Cuccittini']
print(f"Messi events: {len(messi_events)}")

# 4. FILTER BY TIME
# First half only
first_half = events[events['period'] == 1]

# Last 15 minutes of regular time
late_events = events[(events['minute'] >= 75) & (events['minute'] < 90)]

# 5. FILTER BY LOCATION (final third)
# StatsBomb: x > 80 is final third
final_third = events[events['location'].apply(
    lambda loc: loc[0] > 80 if isinstance(loc, list) else False
)]

# 6. MULTIPLE CONDITIONS
# Messi's successful passes in the final third
messi_passes_final_third = events[
    (events['player'] == 'Lionel Andrés Messi Cuccittini') &
    (events['type'] == 'Pass') &
    (events['pass_outcome'].isna()) &  # Successful pass = no outcome
    (events['location'].apply(lambda loc: loc[0] > 80 if isinstance(loc, list) else False))
]
print(f"Messi final third passes (successful): {len(messi_passes_final_third)}")

# 7. FILTER BY OUTCOME
# Successful passes only (pass_outcome is null for successful passes)
successful_passes = events[
    (events['type'] == 'Pass') &
    (events['pass_outcome'].isna())
]

# Goals only
goals = events[
    (events['type'] == 'Shot') &
    (events['shot_outcome'] == 'Goal')
]
print(f"Goals in match: {len(goals)}")

from statsbombpy import sb
import pandas as pd

events = sb.events(match_id=3869685)

# 1. BASIC AGGREGATION BY TEAM
team_stats = events.groupby('team').agg(
    total_events=('type', 'count'),
    passes=('type', lambda x: (x == 'Pass').sum()),
    shots=('type', lambda x: (x == 'Shot').sum()),
    pressures=('type', lambda x: (x == 'Pressure').sum())
)
print("Team Statistics:")
print(team_stats)

# 2. SHOT STATISTICS BY TEAM
shots = events[events['type'] == 'Shot']
shot_stats = shots.groupby('team').agg(
    total_shots=('type', 'count'),
    goals=('shot_outcome', lambda x: (x == 'Goal').sum()),
    total_xG=('shot_statsbomb_xg', 'sum'),
    avg_xG=('shot_statsbomb_xg', 'mean'),
    on_target=('shot_outcome', lambda x: x.isin(['Goal', 'Saved']).sum())
).round(2)
print("\nShot Statistics:")
print(shot_stats)

# 3. PLAYER-LEVEL STATISTICS
player_stats = events.groupby(['team', 'player']).agg(
    total_actions=('type', 'count'),
    passes=('type', lambda x: (x == 'Pass').sum()),
    shots=('type', lambda x: (x == 'Shot').sum()),
    xG=('shot_statsbomb_xg', 'sum')
).reset_index()

# Top 10 players by actions
print("\nTop 10 Players by Actions:")
print(player_stats.nlargest(10, 'total_actions')[['player', 'team', 'total_actions']])

# 4. PASS COMPLETION BY PLAYER
passes = events[events['type'] == 'Pass']
pass_stats = passes.groupby('player').agg(
    total_passes=('type', 'count'),
    successful=('pass_outcome', lambda x: x.isna().sum()),
).assign(
    completion_rate=lambda df: (df['successful'] / df['total_passes'] * 100).round(1)
).sort_values('total_passes', ascending=False)

print("\nPass Completion Rates (min 20 passes):")
print(pass_stats[pass_stats['total_passes'] >= 20].head(10))

# 5. TIME-BASED AGGREGATION (events per 15 minutes)
events['time_bin'] = pd.cut(events['minute'], bins=range(0, 135, 15))
time_stats = events.groupby(['team', 'time_bin']).agg(
    events=('type', 'count'),
    shots=('type', lambda x: (x == 'Shot').sum())
)
print("\nEvents by 15-minute intervals:")
print(time_stats.head(10))

import pandas as pd
from statsbombpy import sb

events = sb.events(match_id=3869685)

# 1. CHECK FOR MISSING VALUES
print("Missing values per column:")
print(events.isnull().sum().sort_values(ascending=False).head(20))

# 2. UNDERSTAND MISSING PATTERNS
# For shots: check xG availability
shots = events[events['type'] == 'Shot']
print(f"\nShots with xG: {shots['shot_statsbomb_xg'].notna().sum()}")
print(f"Shots without xG: {shots['shot_statsbomb_xg'].isna().sum()}")

# 3. PASS OUTCOME - null means SUCCESS
passes = events[events['type'] == 'Pass']
successful = passes['pass_outcome'].isna().sum()
unsuccessful = passes['pass_outcome'].notna().sum()
print(f"\nPass outcomes:")
print(f"  Successful (null): {successful}")
print(f"  Unsuccessful: {unsuccessful}")
print(f"  Completion rate: {successful/(successful+unsuccessful)*100:.1f}%")

# 4. FILLING MISSING VALUES (when appropriate)
# Example: Fill missing xG with 0 for non-shot events
events['shot_xg_filled'] = events['shot_statsbomb_xg'].fillna(0)

# Example: Fill missing player positions with 'Unknown'
events['position_filled'] = events['position'].fillna('Unknown')

# 5. DROPPING ROWS WITH MISSING CRITICAL DATA
# Only analyze events with complete location data
events_with_location = events.dropna(subset=['location'])
print(f"\nEvents with location: {len(events_with_location)}")
print(f"Events without location: {len(events) - len(events_with_location)}")

import pandas as pd
from statsbombpy import sb

# Load multiple matches
matches = sb.matches(competition_id=43, season_id=106)  # World Cup 2022

# Load events for multiple matches
all_events = []
for match_id in matches['match_id'].head(5):  # First 5 matches
    events = sb.events(match_id=match_id)
    events['match_id'] = match_id
    all_events.append(events)

all_events = pd.concat(all_events, ignore_index=True)
print(f"Total events across 5 matches: {len(all_events)}")

# JOIN: Add match info to events
match_info = matches[['match_id', 'home_team', 'away_team', 'home_score', 'away_score']]
events_with_match = all_events.merge(match_info, on='match_id', how='left')

print("\nEvents with match info:")
print(events_with_match[['match_id', 'home_team', 'away_team', 'type', 'player']].head())

# AGGREGATE: Player stats across all matches
player_tournament_stats = all_events.groupby('player').agg(
    matches=('match_id', 'nunique'),
    total_actions=('type', 'count'),
    goals=('shot_outcome', lambda x: (x == 'Goal').sum()),
    xG=('shot_statsbomb_xg', 'sum'),
    passes=('type', lambda x: (x == 'Pass').sum())
).reset_index().sort_values('total_actions', ascending=False)

print("\nPlayer tournament stats (top 10 by actions):")
print(player_tournament_stats.head(10))

# Create match result column
events_with_match['match_result'] = events_with_match.apply(
    lambda row: 'Win' if (
        (row['team'] == row['home_team'] and row['home_score'] > row['away_score']) or
        (row['team'] == row['away_team'] and row['away_score'] > row['home_score'])
    ) else ('Loss' if (
        (row['team'] == row['home_team'] and row['home_score'] < row['away_score']) or
        (row['team'] == row['away_team'] and row['away_score'] < row['home_score'])
    ) else 'Draw'),
    axis=1
)

# Event type distribution bar chart
from statsbombpy import sb
import matplotlib.pyplot as plt
import seaborn as sns

# Load match data
events = sb.events(match_id=3869685)

# Count events by type
event_counts = events["type"].value_counts().head(15)

# Create bar chart
fig, ax = plt.subplots(figsize=(10, 8))
colors = plt.cm.Greens(event_counts / event_counts.max())

bars = ax.barh(event_counts.index, event_counts.values, color=colors)
ax.set_xlabel("Count", fontsize=12)
ax.set_ylabel("Event Type", fontsize=12)
ax.set_title("Event Type Distribution\nWorld Cup 2022 Final", fontsize=16, fontweight="bold")

# Add value labels
for bar, val in zip(bars, event_counts.values):
    ax.text(val + 5, bar.get_y() + bar.get_height()/2, str(val),
            va="center", fontsize=10)

plt.tight_layout()
plt.show()

# Team comparison grouped bar chart
import pandas as pd
import matplotlib.pyplot as plt

# Filter key events
key_events = events[events["type"].isin(["Pass", "Shot", "Pressure", "Dribble", "Tackle"])]
team_counts = key_events.groupby(["team", "type"]).size().unstack(fill_value=0)

# Create grouped bar chart
fig, ax = plt.subplots(figsize=(12, 6))
x = range(len(team_counts.columns))
width = 0.35

teams = team_counts.index.tolist()
colors = {"Argentina": "#75AADB", "France": "#002395"}

for i, team in enumerate(teams):
    offset = width * (i - 0.5)
    bars = ax.bar([xi + offset for xi in x], team_counts.loc[team],
                  width, label=team, color=colors.get(team, "gray"))

ax.set_xlabel("Event Type", fontsize=12)
ax.set_ylabel("Count", fontsize=12)
ax.set_title("Team Action Comparison\nKey Event Types", fontsize=16, fontweight="bold")
ax.set_xticks(x)
ax.set_xticklabels(team_counts.columns, rotation=45, ha="right")
ax.legend()

plt.tight_layout()
plt.show()

# Events over time line chart
import matplotlib.pyplot as plt
import pandas as pd

# Create time bins
passes = events[events["type"] == "Pass"].copy()
passes["time_bin"] = pd.cut(passes["minute"], bins=range(0, 130, 5))

# Count by team and time
time_counts = passes.groupby(["team", "time_bin"]).size().unstack(level=0, fill_value=0)

# Plot
fig, ax = plt.subplots(figsize=(14, 6))
colors = {"Argentina": "#75AADB", "France": "#002395"}

for team in time_counts.columns:
    ax.plot(range(len(time_counts)), time_counts[team],
            marker="o", label=team, color=colors.get(team, "gray"), linewidth=2)

ax.set_xlabel("Time Period", fontsize=12)
ax.set_ylabel("Pass Count", fontsize=12)
ax.set_title("Passing Activity Over Match Time", fontsize=16, fontweight="bold")
ax.set_xticks(range(len(time_counts)))
ax.set_xticklabels([str(x) for x in time_counts.index], rotation=45, ha="right", fontsize=8)
ax.legend()
ax.grid(alpha=0.3)

plt.tight_layout()
plt.show()

# Event location scatter plot
from mplsoccer import Pitch
import matplotlib.pyplot as plt

# Filter events with locations
locations = events[events["x"].notna() & events["y"].notna()].copy()
locations = locations[locations["type"].isin(["Pass", "Shot", "Carry"])]

# Create pitch for each team
teams = locations["team"].unique()
fig, axes = plt.subplots(1, 2, figsize=(16, 8))

colors = {"Pass": "#87CEEB", "Shot": "#FFD700", "Carry": "#FF6B6B"}
pitch = Pitch(pitch_color="#1B5E20", line_color="white")

for ax, team in zip(axes, teams):
    pitch.draw(ax=ax)
    team_data = locations[locations["team"] == team]

    for event_type, color in colors.items():
        type_data = team_data[team_data["type"] == event_type]
        ax.scatter(type_data["x"], type_data["y"], c=color,
                   alpha=0.4, s=20, label=event_type)

    ax.set_title(team, fontsize=14, fontweight="bold")
    ax.legend(loc="upper left", fontsize=8)

fig.suptitle("Event Locations by Type and Team", fontsize=16, fontweight="bold")
plt.tight_layout()
plt.show()