Capstone - Complete Analytics System

# Python: Load league data from multiple sources
import pandas as pd
import numpy as np
from typing import Dict, List
import soccerdata as sd

# Initialize data sources
fbref = sd.FBref(leagues=["ENG-Premier League", "ESP-La Liga",
                          "GER-Bundesliga", "ITA-Serie A",
                          "FRA-Ligue 1", "NED-Eredivisie"])

# Get team season statistics
def get_league_stats(league: str, season: str = "2023-2024") -> pd.DataFrame:
    """Get league-level statistics."""
    try:
        stats = fbref.read_team_season_stats(stat_type="standard")
        return stats.loc[(league, season), :]
    except Exception as e:
        print(f"Error fetching {league}: {e}")
        return pd.DataFrame()

# Collect all league data
leagues = ["ENG-Premier League", "ESP-La Liga", "GER-Bundesliga",
           "ITA-Serie A", "FRA-Ligue 1", "NED-Eredivisie"]

league_data = {}
for league in leagues:
    league_data[league] = get_league_stats(league)

# Calculate league averages
def calculate_league_averages(data: Dict[str, pd.DataFrame]) -> pd.DataFrame:
    """Calculate average metrics per league."""
    averages = []

    for league, df in data.items():
        if df.empty:
            continue

        avg = {
            "league": league,
            "teams": len(df),
            "avg_goals_for": df["Gls"].mean(),
            "avg_goals_against": df["GA"].mean(),
            "avg_xg": df["xG"].mean() if "xG" in df.columns else np.nan,
            "avg_possession": df["Poss"].mean() if "Poss" in df.columns else np.nan,
            "total_goals": df["Gls"].sum()
        }
        avg["goals_per_game"] = avg["total_goals"] / (avg["teams"] * (avg["teams"] - 1))
        averages.append(avg)

    return pd.DataFrame(averages)

league_averages = calculate_league_averages(league_data)
print(league_averages)

# Python: Calculate league quality from UEFA coefficients
import pandas as pd
import numpy as np

# UEFA coefficients (2023-24 season)
uefa_coefficients = pd.DataFrame({
    "league": ["Premier League", "La Liga", "Serie A", "Bundesliga",
               "Ligue 1", "Eredivisie", "Liga Portugal", "Pro League",
               "Scottish Premiership", "Austrian Bundesliga"],
    "country": ["ENG", "ESP", "ITA", "GER", "FRA",
                "NED", "POR", "BEL", "SCO", "AUT"],
    "coefficient": [90.500, 76.571, 74.980, 73.357, 59.415,
                    54.900, 50.716, 37.600, 35.750, 33.825]
})

# Normalize to Premier League = 1.0
uefa_coefficients["quality_index"] = (
    uefa_coefficients["coefficient"] / uefa_coefficients["coefficient"].max()
)

# Apply non-linear transformation (diminishing returns)
uefa_coefficients["adjusted_quality"] = uefa_coefficients["quality_index"] ** 0.7

# Calculate stat multipliers
uefa_coefficients["stat_multiplier"] = (
    uefa_coefficients["adjusted_quality"] /
    uefa_coefficients["adjusted_quality"].max()
)

uefa_quality = uefa_coefficients.sort_values("coefficient", ascending=False)
print(uefa_quality[["league", "coefficient", "quality_index", "stat_multiplier"]])

# Python: League quality from transfer market data
import pandas as pd
import numpy as np

# Average squad market values (millions EUR, 2023-24)
market_values = pd.DataFrame({
    "league": ["Premier League", "La Liga", "Serie A", "Bundesliga",
               "Ligue 1", "Eredivisie", "Liga Portugal", "Pro League",
               "Scottish Premiership", "Austrian Bundesliga"],
    "avg_squad_value": [548, 312, 267, 298, 215, 89, 78, 52, 28, 31],
    "total_league_value": [10960, 6240, 5340, 5364, 3870,
                           1602, 1404, 832, 336, 558]
})

# Calculate quality indices
market_values["value_index"] = (
    market_values["avg_squad_value"] / market_values["avg_squad_value"].max()
)

# Log transformation for better distribution
market_values["log_value"] = np.log(market_values["avg_squad_value"])
market_values["log_normalized"] = (
    (market_values["log_value"] - market_values["log_value"].min()) /
    (market_values["log_value"].max() - market_values["log_value"].min())
)

# Weighted quality index
market_values["market_quality"] = (
    0.5 * market_values["value_index"] +
    0.5 * market_values["log_normalized"]
)

# Transfer flow analysis
transfer_flows = pd.DataFrame({
    "league": ["Premier League", "La Liga", "Serie A", "Bundesliga",
               "Ligue 1", "Eredivisie", "Liga Portugal"],
    "net_spend_5yr": [3200, 450, -180, -320, -890, -420, -380],
    "players_in_from_lower": [145, 98, 87, 92, 75, 34, 28],
    "players_out_to_higher": [12, 45, 52, 48, 78, 89, 72]
})

print(market_values[["league", "avg_squad_value", "value_index", "market_quality"]])

# Python: Analyze player performance when changing leagues
import pandas as pd
import numpy as np
from typing import Tuple

# Simulated transfer data with before/after stats
transfers = pd.DataFrame({
    "player": ["Player A", "Player B", "Player C", "Player D", "Player E"],
    "from_league": ["Eredivisie", "Ligue 1", "Bundesliga",
                    "Serie A", "Liga Portugal"],
    "to_league": ["Premier League", "Premier League", "Premier League",
                  "Premier League", "La Liga"],
    "g90_before": [0.72, 0.58, 0.45, 0.52, 0.85],
    "g90_after": [0.41, 0.38, 0.42, 0.48, 0.61],
    "xg90_before": [0.65, 0.52, 0.48, 0.49, 0.78],
    "xg90_after": [0.45, 0.41, 0.44, 0.45, 0.55],
    "minutes_before": [2800, 2650, 2900, 2750, 2600],
    "minutes_after": [2100, 2400, 2700, 2500, 2300]
})

# Calculate performance retention rate
transfers["g90_retention"] = transfers["g90_after"] / transfers["g90_before"]
transfers["xg90_retention"] = transfers["xg90_after"] / transfers["xg90_before"]
transfers["overall_retention"] = (
    transfers["g90_retention"] + transfers["xg90_retention"]
) / 2

# Aggregate by league pair
league_difficulty = transfers.groupby(["from_league", "to_league"]).agg({
    "player": "count",
    "overall_retention": "mean"
}).reset_index()

league_difficulty.columns = ["from_league", "to_league", "n_transfers", "avg_retention"]
league_difficulty["difficulty_ratio"] = 1 / league_difficulty["avg_retention"]

print(league_difficulty)

# Python: Comprehensive league adjustment model
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict

# Combine all quality measures
league_quality_data = pd.DataFrame({
    "league": ["Premier League", "La Liga", "Serie A", "Bundesliga",
               "Ligue 1", "Eredivisie", "Liga Portugal", "Pro League"],
    "uefa_quality": [1.000, 0.896, 0.884, 0.872, 0.752, 0.713, 0.674, 0.552],
    "market_quality": [1.000, 0.569, 0.487, 0.544, 0.392, 0.162, 0.142, 0.095],
    "transfer_flow_quality": [1.000, 0.850, 0.820, 0.830, 0.700, 0.600, 0.580, 0.450],
    "performance_delta": [1.000, 0.920, 0.900, 0.940, 0.800, 0.650, 0.700, 0.550]
})

# Weights based on reliability of each measure
weights = {
    "uefa": 0.25,
    "market": 0.20,
    "transfer": 0.25,
    "performance": 0.30
}

# Calculate composite quality score
league_quality_data["composite_quality"] = (
    weights["uefa"] * league_quality_data["uefa_quality"] +
    weights["market"] * league_quality_data["market_quality"] +
    weights["transfer"] * league_quality_data["transfer_flow_quality"] +
    weights["performance"] * league_quality_data["performance_delta"]
)

# Adjustment multiplier
league_quality_data["adjustment_multiplier"] = (
    league_quality_data["composite_quality"] /
    league_quality_data["composite_quality"].max()
)

# Confidence based on measure agreement
league_quality_data["measure_sd"] = league_quality_data[
    ["uefa_quality", "market_quality", "transfer_flow_quality", "performance_delta"]
].std(axis=1)
league_quality_data["confidence"] = 1 - (league_quality_data["measure_sd"] / 0.3)

@dataclass
class LeagueAdjuster:
    """Adjust player statistics between leagues."""
    quality_table: pd.DataFrame

    def adjust_stat(self, stat: float, from_league: str, to_league: str) -> float:
        """Adjust a statistic from one league to another."""
        from_mult = self.quality_table.loc[
            self.quality_table["league"] == from_league,
            "adjustment_multiplier"
        ].values[0]

        to_mult = self.quality_table.loc[
            self.quality_table["league"] == to_league,
            "adjustment_multiplier"
        ].values[0]

        return stat * (from_mult / to_mult)

# Create adjuster
adjuster = LeagueAdjuster(league_quality_data)

# Example: Adjust goals from Eredivisie to Premier League
eredivisie_goals = 20
adjusted_goals = adjuster.adjust_stat(20, "Eredivisie", "Premier League")
print(f"{eredivisie_goals} goals in Eredivisie ≈ {adjusted_goals:.1f} goals in Premier League")

# Python: Create league style profiles
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy.spatial.distance import pdist, squareform

# League style metrics (standardized 0-1 scores)
league_styles = pd.DataFrame({
    "league": ["Premier League", "La Liga", "Serie A",
               "Bundesliga", "Ligue 1", "Eredivisie"],
    "tempo": [0.85, 0.45, 0.35, 0.90, 0.55, 0.70],
    "pressing_intensity": [0.90, 0.50, 0.40, 0.95, 0.60, 0.55],
    "physical_duels": [0.95, 0.55, 0.70, 0.75, 0.80, 0.45],
    "technical_quality": [0.75, 0.95, 0.85, 0.70, 0.70, 0.80],
    "tactical_discipline": [0.70, 0.85, 0.95, 0.75, 0.75, 0.60],
    "attacking_directness": [0.80, 0.55, 0.45, 0.85, 0.65, 0.90],
    "defensive_organization": [0.75, 0.80, 0.95, 0.70, 0.75, 0.55]
})

def create_radar_chart(df: pd.DataFrame, league: str):
    """Create radar chart for a league style profile."""
    categories = [col for col in df.columns if col != "league"]
    league_data = df[df["league"] == league][categories].values.flatten()

    # Number of categories
    N = len(categories)
    angles = [n / float(N) * 2 * np.pi for n in range(N)]
    angles += angles[:1]  # Complete the loop

    values = list(league_data) + [league_data[0]]

    fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
    ax.plot(angles, values, "o-", linewidth=2)
    ax.fill(angles, values, alpha=0.25)
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(categories, size=8)
    ax.set_ylim(0, 1)
    ax.set_title(league, size=14, fontweight="bold")

    return fig

# Calculate style similarity matrix
style_features = league_styles.set_index("league")
distances = squareform(pdist(style_features.values, metric="euclidean"))
style_similarity = pd.DataFrame(
    distances,
    index=style_features.index,
    columns=style_features.index
)

print("League Style Distances:")
print(style_similarity.round(2))

# Python: Position-specific league adjustments
import pandas as pd
import numpy as np

# Position-specific adjustment factors
position_adjustments = pd.DataFrame({
    "position": ["Striker", "Winger", "Attacking Mid",
                 "Central Mid", "Defensive Mid",
                 "Full-Back", "Center-Back", "Goalkeeper"],
    "league_sensitivity": [1.20, 1.15, 1.10, 1.00, 0.95, 0.90, 0.85, 0.80],
    "avg_stat_retention": [0.72, 0.75, 0.78, 0.82, 0.85, 0.88, 0.90, 0.92]
})

class PositionAwareAdjuster:
    """League adjuster with position-specific sensitivity."""

    def __init__(self, league_quality: pd.DataFrame,
                 position_adj: pd.DataFrame):
        self.league_quality = league_quality
        self.position_adj = position_adj

    def adjust_stat(self, stat: float, from_league: str,
                    to_league: str, position: str) -> float:
        """Adjust stat with position-specific sensitivity."""
        # Get league quality values
        from_quality = self.league_quality.loc[
            self.league_quality["league"] == from_league,
            "composite_quality"
        ].values[0]

        to_quality = self.league_quality.loc[
            self.league_quality["league"] == to_league,
            "composite_quality"
        ].values[0]

        # Get position sensitivity
        pos_sensitivity = self.position_adj.loc[
            self.position_adj["position"] == position,
            "league_sensitivity"
        ].values[0]

        # Calculate position-weighted adjustment
        quality_ratio = from_quality / to_quality
        adjusted_ratio = 1 + (quality_ratio - 1) * pos_sensitivity

        return stat * adjusted_ratio

# Create adjuster
pos_adjuster = PositionAwareAdjuster(league_quality_data, position_adjustments)

# Example comparisons
examples = [
    {"player": "Striker A", "position": "Striker", "stat": 0.75},
    {"player": "Midfielder B", "position": "Central Mid", "stat": 0.85},
    {"player": "Defender C", "position": "Center-Back", "stat": 0.90}
]

print("Position-specific adjustments (Eredivisie → Premier League):")
for ex in examples:
    adjusted = pos_adjuster.adjust_stat(
        ex["stat"], "Eredivisie", "Premier League", ex["position"]
    )
    print(f"{ex['player']} ({ex['position']}): {ex['stat']:.2f} → {adjusted:.2f}")

# Python: Complete scouting tool with league adjustments
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict, Optional

# Player scouting database
scouting_data = pd.DataFrame({
    "player": ["Memphis Depay", "Luis Suarez", "Kevin De Bruyne",
               "Virgil van Dijk", "Bruno Fernandes"],
    "position": ["Winger", "Striker", "Attacking Mid",
                 "Center-Back", "Attacking Mid"],
    "league": ["Eredivisie", "Eredivisie", "Bundesliga",
               "Scottish Premiership", "Liga Portugal"],
    "age": [21, 24, 23, 24, 25],
    "goals": [0.52, 0.85, 0.28, 0.08, 0.35],
    "assists": [0.31, 0.42, 0.48, 0.04, 0.28],
    "xg": [0.45, 0.78, 0.25, 0.05, 0.32],
    "xa": [0.28, 0.35, 0.52, 0.03, 0.30],
    "market_value_m": [25, 22, 18, 8, 15]
})

@dataclass
class ScoutingTool:
    """Scouting tool with league adjustments."""

    league_quality: Dict[str, float] = None
    position_sensitivity: Dict[str, float] = None

    def __post_init__(self):
        if self.league_quality is None:
            self.league_quality = {
                "Eredivisie": 0.713,
                "Bundesliga": 0.872,
                "Scottish Premiership": 0.535,
                "Liga Portugal": 0.674,
                "Premier League": 1.0
            }
        if self.position_sensitivity is None:
            self.position_sensitivity = {
                "Striker": 1.20, "Winger": 1.15, "Attacking Mid": 1.10,
                "Central Mid": 1.0, "Defensive Mid": 0.95,
                "Full-Back": 0.90, "Center-Back": 0.85, "Goalkeeper": 0.80
            }

    def adjust_stat(self, stat: float, league: str, position: str) -> float:
        """Adjust stat to Premier League equivalent."""
        league_mult = self.league_quality.get(league, 1.0)
        pos_mult = self.position_sensitivity.get(position, 1.0)
        return stat * league_mult * pos_mult

    def generate_report(self, df: pd.DataFrame, player_name: str) -> str:
        """Generate scouting report for a player."""
        player = df[df["player"] == player_name].iloc[0]

        goals_adj = self.adjust_stat(
            player["goals"], player["league"], player["position"]
        )
        assists_adj = self.adjust_stat(
            player["assists"], player["league"], player["position"]
        )

        production = (goals_adj * 1.5 + assists_adj) / 2
        value_eff = production / (player["market_value_m"] / 100)

        report = f"""
=== SCOUTING REPORT: {player_name} ===
Position: {player["position"]} | Age: {player["age"]} | League: {player["league"]}
Market Value: €{player["market_value_m"]:.1f}M

Raw Stats (per 90):
  Goals: {player["goals"]:.2f} | Assists: {player["assists"]:.2f}

Premier League Adjusted:
  Goals: {goals_adj:.2f} | Assists: {assists_adj:.2f}

Value Efficiency Score: {value_eff:.2f}
"""
        return report

# Create tool and generate report
scout = ScoutingTool()
print(scout.generate_report(scouting_data, "Luis Suarez"))