Capstone - Complete Analytics System

from statsbombpy import sb
import pandas as pd

# 1. GET ALL AVAILABLE COMPETITIONS
competitions = sb.competitions()
print("Available competitions:")
print(competitions[['competition_name', 'season_name', 'competition_gender']].drop_duplicates())

# 2. GET MATCHES FOR A COMPETITION
# World Cup 2022
wc_matches = sb.matches(competition_id=43, season_id=106)
print(f"\nWorld Cup 2022 matches: {len(wc_matches)}")
print(wc_matches[['match_date', 'home_team', 'away_team', 'home_score', 'away_score']].head())

# 3. GET EVENTS FOR A MATCH
events = sb.events(match_id=3869685)  # WC Final
print(f"\nEvents in WC Final: {len(events)}")

# 4. GET LINEUPS
lineups = sb.lineups(match_id=3869685)
print("\nArgentina starting XI:")
argentina_lineup = lineups['Argentina']
starters = argentina_lineup[argentina_lineup['positions'].apply(
    lambda x: x[0]['start_reason'] == 'Starting XI' if x else False
)]
print(starters[['player_name', 'jersey_number']].head(11))

# 5. GET 360 FREEZE FRAMES (where available)
# Provides positions of ALL players at moment of event
try:
    frames = sb.frames(match_id=3869685)
    print(f"\n360 frames available: {len(frames)}")
except:
    print("\n360 data not available for this match")

# 6. BATCH DOWNLOAD - All events for a competition
def get_all_competition_events(competition_id, season_id):
    """Download all events for a competition."""
    matches = sb.matches(competition_id=competition_id, season_id=season_id)
    all_events = []

    for idx, match in matches.iterrows():
        events = sb.events(match_id=match['match_id'])
        events['match_id'] = match['match_id']
        events['competition'] = match['competition']
        all_events.append(events)
        print(f"Downloaded match {idx+1}/{len(matches)}")

    return pd.concat(all_events, ignore_index=True)

# Uncomment to download (takes a few minutes)
# wc_events = get_all_competition_events(43, 106)

import soccerdata as sd

# Initialize FBref scraper
fbref = sd.FBref(leagues="ENG-Premier League", seasons="2023-2024")

# 1. GET PLAYER SEASON STATS
# Standard stats (goals, assists, minutes)
standard = fbref.read_player_season_stats(stat_type="standard")
print("Standard stats columns:")
print(standard.columns.tolist()[:15])

# 2. SHOOTING STATS
shooting = fbref.read_player_season_stats(stat_type="shooting")
top_shooters = shooting.nsmallest(10, ('Expected', 'xG'))
print("\nTop xG players:")
print(top_shooters[[('Shooting', 'Gls'), ('Expected', 'xG')]].head(10))

# 3. PASSING STATS
passing = fbref.read_player_season_stats(stat_type="passing")

# 4. DEFENSIVE STATS
defense = fbref.read_player_season_stats(stat_type="defense")

# 5. POSSESSION STATS (touches, carries, etc.)
possession = fbref.read_player_season_stats(stat_type="possession")

# 6. TEAM STATS
team_stats = fbref.read_team_season_stats(stat_type="standard")
print("\nTeam standings:")
print(team_stats.head())

# 7. MATCH SCHEDULES AND RESULTS
schedule = fbref.read_schedule()
print(f"\nMatches in schedule: {len(schedule)}")

# 8. COMBINE MULTIPLE STAT TYPES
# Merge standard and shooting stats
combined = standard.join(shooting, rsuffix='_shoot')
print(f"\nCombined stats shape: {combined.shape}")

import soccerdata as sd
# Or use: from understatapi import UnderstatClient

# Initialize Understat scraper
understat = sd.Understat(leagues="ENG-Premier League", seasons="2023-2024")

# 1. GET PLAYER STATS
player_stats = understat.read_player_season_stats()
print("Top scorers with xG:")
print(player_stats.nlargest(10, 'goals')[['player', 'team', 'goals', 'xG', 'shots']])

# 2. GET TEAM STATS
team_stats = understat.read_team_season_stats()
print("\nTeam xG stats:")
print(team_stats[['team', 'xG', 'xGA', 'scored', 'missed']])

# 3. GET SHOT-LEVEL DATA
# This is Understat's killer feature
shot_data = understat.read_shot_events()
print(f"\nTotal shots this season: {len(shot_data)}")

# Analyze a single player's shots
haaland_shots = shot_data[shot_data['player'] == 'Erling Haaland']
print(f"\nHaaland shots: {len(haaland_shots)}")
print(f"Haaland total xG: {haaland_shots['xG'].sum():.2f}")
print(f"Haaland goals: {(haaland_shots['result'] == 'Goal').sum()}")

# 4. ANALYZE SHOT QUALITY
avg_xg_by_result = shot_data.groupby('result')['xG'].mean()
print("\nAverage xG by shot result:")
print(avg_xg_by_result)

import soccerdata as sd

# Initialize Transfermarkt scraper
tm = sd.Transfermarkt(leagues="ENG-Premier League", seasons="2023-2024")

# 1. GET PLAYER MARKET VALUES
player_values = tm.read_player_market_values()
print("Most valuable players:")
print(player_values.nlargest(10, 'market_value')[['player', 'team', 'market_value', 'age']])

# 2. GET TEAM MARKET VALUES
team_values = player_values.groupby('team')['market_value'].sum().sort_values(ascending=False)
print("\nMost valuable squads:")
print(team_values.head(10))

# 3. AGE PROFILE
avg_age = player_values.groupby('team')['age'].mean().sort_values()
print("\nYoungest squads:")
print(avg_age.head(5))

# 4. VALUE PER AGE
value_by_age = player_values.groupby('age')['market_value'].agg(['mean', 'count'])
print("\nValue by age (with sufficient sample):")
print(value_by_age[value_by_age['count'] > 10].head(10))

# Data source feature comparison
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

# Create comparison matrix
data = {
    "Source": ["StatsBomb", "FBref", "Understat", "Transfermarkt", "WhoScored"],
    "Event Data": [5, 2, 3, 0, 2],
    "xG Models": [5, 4, 5, 0, 4],
    "Historical": [3, 5, 4, 5, 4],
    "Market Values": [0, 0, 0, 5, 0],
    "Free Access": [4, 5, 5, 5, 4]
}
df = pd.DataFrame(data)
df.set_index("Source", inplace=True)

# Create heatmap
fig, ax = plt.subplots(figsize=(10, 6))
heatmap = sns.heatmap(df, annot=True, fmt="d", cmap="Greens",
                      cbar=True, linewidths=2, linecolor="white",
                      annot_kws={"fontsize": 14, "fontweight": "bold"})

ax.set_title("Football Data Source Comparison\nRatings: 0 (None) to 5 (Excellent)",
             fontsize=16, fontweight="bold", pad=20)
ax.set_xlabel("Feature Category", fontsize=12)
ax.set_ylabel("Data Source", fontsize=12)
plt.xticks(rotation=45, ha="right")

plt.tight_layout()
plt.show()

# Competition coverage bar chart
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Data
sources = ["StatsBomb Free", "FBref", "Understat", "Transfermarkt"]
competitions = ["Premier League", "La Liga", "Serie A", "Bundesliga", "Ligue 1"]

data = {
    "StatsBomb Free": [0, 16, 0, 0, 0],
    "FBref": [30, 30, 30, 30, 30],
    "Understat": [10, 10, 10, 10, 10],
    "Transfermarkt": [50, 50, 50, 50, 50]
}

# Plot
fig, ax = plt.subplots(figsize=(12, 6))
x = np.arange(len(competitions))
width = 0.2
colors = ["#E63946", "#457B9D", "#2A9D8F", "#E9C46A"]

for i, (source, color) in enumerate(zip(sources, colors)):
    offset = width * (i - 1.5)
    ax.bar(x + offset, data[source], width, label=source, color=color)

ax.set_xlabel("Competition", fontsize=12)
ax.set_ylabel("Seasons Available", fontsize=12)
ax.set_title("Historical Data Coverage by League\nApproximate seasons of data available",
             fontsize=16, fontweight="bold")
ax.set_xticks(x)
ax.set_xticklabels(competitions, rotation=45, ha="right")
ax.legend(loc="upper right")

plt.tight_layout()
plt.show()

# Data update frequency timeline
import matplotlib.pyplot as plt
import numpy as np

sources = ["StatsBomb", "FBref", "Understat", "Transfermarkt", "WhoScored"]
delays = [24, 2, 1, 168, 1]  # Hours
types = ["Batch", "Near-realtime", "Realtime", "Weekly", "Realtime"]

colors = {
    "Realtime": "#2A9D8F",
    "Near-realtime": "#457B9D",
    "Batch": "#E9C46A",
    "Weekly": "#E76F51"
}

fig, ax = plt.subplots(figsize=(10, 6))
bars = ax.bar(sources, delays, color=[colors[t] for t in types])

# Add value labels
for bar, delay in zip(bars, delays):
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 5,
            f"{delay}h", ha="center", fontweight="bold")

ax.set_yscale("log")
ax.set_xlabel("Data Source", fontsize=12)
ax.set_ylabel("Delay (hours, log scale)", fontsize=12)
ax.set_title("Data Update Frequency by Source\nHours after match end until data available",
             fontsize=16, fontweight="bold")

# Legend
from matplotlib.patches import Patch
legend_elements = [Patch(facecolor=c, label=t) for t, c in colors.items()]
ax.legend(handles=legend_elements, loc="upper right")

plt.tight_layout()
plt.show()