Capstone - Complete Analytics System

# Loading Women's Football Data from StatsBomb
from statsbombpy import sb
import pandas as pd

# Get available competitions
competitions = sb.competitions()

# Filter for women's competitions
womens_comps = competitions[
    competitions["competition_name"].str.contains(
        "Women|WSL|NWSL|FAWSL", case=False, na=False
    )
]

print(womens_comps[["competition_name", "season_name"]])

# Load Women's World Cup 2023 data
wwc_matches = sb.matches(competition_id=72, season_id=107)

# Load event data for matches
all_events = []
for match_id in wwc_matches["match_id"]:
    events = sb.events(match_id=match_id)
    all_events.append(events)

wwc_events = pd.concat(all_events, ignore_index=True)

# Summarize available data
print(f"Total matches: {len(wwc_matches)}")
print(f"Total events: {len(wwc_events)}")

# Event type breakdown
event_summary = wwc_events["type"].value_counts().head(10)
print(event_summary)

# Scraping Women's Football Stats from FBref
import pandas as pd

# FBref URLs for women's leagues
WSL_URL = "https://fbref.com/en/comps/189/2023-2024/2023-2024-Womens-Super-League-Stats"
LIGA_F_URL = "https://fbref.com/en/comps/230/Liga-F-Stats"
NWSL_URL = "https://fbref.com/en/comps/182/NWSL-Stats"

def get_league_table(url):
    """Scrape league standings from FBref"""
    tables = pd.read_html(url)
    # League table is typically the first table
    standings = tables[0]
    return standings

# Get WSL standings
wsl_standings = get_league_table(WSL_URL)
print("WSL Standings:")
print(wsl_standings[["Squad", "MP", "W", "D", "L", "GF", "GA", "GD", "Pts"]].head())

# Alternative: Using soccerdata library
try:
    import soccerdata as sd

    # Initialize FBref reader for women's data
    fbref = sd.FBref(leagues=["ENG-WSL"], seasons=["2023-2024"])

    # Get squad statistics
    squad_stats = fbref.read_team_season_stats()
    print(squad_stats.head())

except ImportError:
    print("Install soccerdata: pip install soccerdata")

# Custom scraping function for player stats
def get_player_stats(url):
    """Extract player statistics from FBref page"""
    tables = pd.read_html(url)
    for table in tables:
        if "Player" in table.columns:
            return table
    return None

# Compare goal-scoring across leagues
def compare_leagues(urls_dict):
    """Compare statistics across multiple women's leagues"""
    comparison = []
    for league, url in urls_dict.items():
        try:
            stats = get_player_stats(url)
            if stats is not None:
                comparison.append({
                    "League": league,
                    "Avg_Goals": stats["Gls"].mean(),
                    "Max_Goals": stats["Gls"].max()
                })
        except:
            pass
    return pd.DataFrame(comparison)

# Building Women's Football Specific xG Model
from statsbombpy import sb
import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import brier_score_loss, roc_auc_score

# Load Women's World Cup data
wwc_matches = sb.matches(competition_id=72, season_id=107)

# Collect all shots
all_shots = []
for match_id in wwc_matches["match_id"]:
    events = sb.events(match_id=match_id)
    shots = events[events["type"] == "Shot"]
    all_shots.append(shots)

shots_df = pd.concat(all_shots, ignore_index=True)

# Extract shot location
shots_df["x"] = shots_df["location"].apply(lambda x: x[0] if x else None)
shots_df["y"] = shots_df["location"].apply(lambda x: x[1] if x else None)

# Calculate features
shots_df["distance"] = np.sqrt(
    (120 - shots_df["x"])**2 + (40 - shots_df["y"])**2
)
shots_df["angle"] = np.arctan2(
    np.abs(40 - shots_df["y"]),
    120 - shots_df["x"]
) * 180 / np.pi

# Binary features
shots_df["is_header"] = (shots_df["shot_body_part"] == "Head").astype(int)
shots_df["is_first_time"] = shots_df["shot_first_time"].fillna(False).astype(int)
shots_df["is_open_play"] = (shots_df["shot_type"] == "Open Play").astype(int)
shots_df["is_goal"] = (shots_df["shot_outcome"] == "Goal").astype(int)

# Baseline statistics
print("Women's WWC Shot Statistics:")
print(f"Total shots: {len(shots_df)}")
print(f"Conversion rate: {shots_df['is_goal'].mean():.3f}")
print(f"Header conversion: {shots_df[shots_df['is_header']==1]['is_goal'].mean():.3f}")

# Prepare model features
features = ["distance", "angle", "is_header", "is_first_time", "is_open_play"]
X = shots_df[features].dropna()
y = shots_df.loc[X.index, "is_goal"]

# Train/test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train xG model
xg_model = LogisticRegression(max_iter=1000)
xg_model.fit(X_train, y_train)

# Predictions
shots_df.loc[X.index, "xG_custom"] = xg_model.predict_proba(X)[:, 1]

# Evaluate
y_pred = xg_model.predict_proba(X_test)[:, 1]
print(f"\nModel Performance:")
print(f"Brier Score: {brier_score_loss(y_test, y_pred):.4f}")
print(f"ROC AUC: {roc_auc_score(y_test, y_pred):.4f}")

# Compare with StatsBomb xG
correlation = shots_df[["xG_custom", "shot_statsbomb_xg"]].corr()
print(f"\nCorrelation with StatsBomb xG: {correlation.iloc[0,1]:.3f}")

# Player Evaluation Framework for Women's Football
from statsbombpy import sb
import pandas as pd
import numpy as np

# Load Women's World Cup data
wwc_matches = sb.matches(competition_id=72, season_id=107)

# Collect all events
all_events = []
for match_id in wwc_matches["match_id"]:
    events = sb.events(match_id=match_id)
    events["match_id"] = match_id
    all_events.append(events)

events_df = pd.concat(all_events, ignore_index=True)

# Calculate player statistics
def calculate_player_stats(events):
    """Calculate comprehensive player statistics"""

    # Group by player
    player_stats = events.groupby(["player", "team"]).agg({
        "match_id": "nunique",
        "type": "count"
    }).reset_index()
    player_stats.columns = ["player", "team", "matches", "events"]

    # Shots and goals
    shots = events[events["type"] == "Shot"].groupby("player").agg({
        "shot_statsbomb_xg": ["count", "sum"],
        "shot_outcome": lambda x: (x == "Goal").sum()
    }).reset_index()
    shots.columns = ["player", "shots", "xG", "goals"]

    # Passes
    passes = events[events["type"] == "Pass"].groupby("player").agg({
        "id": "count",
        "pass_outcome": lambda x: x.isna().mean(),  # Completion rate
        "pass_shot_assist": "sum"
    }).reset_index()
    passes.columns = ["player", "passes", "pass_completion", "key_passes"]

    # Defensive actions
    defensive = events[events["type"].isin(["Pressure", "Interception"])].groupby("player").agg({
        "type": [
            lambda x: (x == "Pressure").sum(),
            lambda x: (x == "Interception").sum()
        ]
    }).reset_index()
    defensive.columns = ["player", "pressures", "interceptions"]

    # Merge all stats
    player_stats = player_stats.merge(shots, on="player", how="left")
    player_stats = player_stats.merge(passes, on="player", how="left")
    player_stats = player_stats.merge(defensive, on="player", how="left")

    return player_stats.fillna(0)

player_stats = calculate_player_stats(events_df)

# Calculate per-90 metrics (estimate minutes)
player_stats["est_minutes"] = player_stats["matches"] * 75
player_stats["xG_p90"] = player_stats["xG"] / player_stats["est_minutes"] * 90
player_stats["shots_p90"] = player_stats["shots"] / player_stats["est_minutes"] * 90
player_stats["pressures_p90"] = player_stats["pressures"] / player_stats["est_minutes"] * 90

# Filter for players with sufficient playing time
qualified = player_stats[player_stats["matches"] >= 3].copy()

# Percentile rankings
for col in ["xG_p90", "shots_p90", "pressures_p90"]:
    qualified[f"{col}_pct"] = qualified[col].rank(pct=True) * 100

# Top performers
top_by_xg = qualified.nlargest(10, "xG_p90")[
    ["player", "team", "matches", "xG", "xG_p90", "xG_p90_pct"]
]
print("Top Performers by xG per 90:")
print(top_by_xg.to_string(index=False))

# Player Radar Charts for Women's Football
import matplotlib.pyplot as plt
import numpy as np
from math import pi

def create_radar_chart(player_data, player_name, metrics):
    """Create radar chart for player comparison"""

    # Get player data
    player = player_data[player_data["player"] == player_name].iloc[0]

    # Get percentile values
    values = [player[f"{m}_p90_pct"] for m in metrics]
    values += values[:1]  # Complete the polygon

    # Set up radar chart
    angles = [n / float(len(metrics)) * 2 * pi for n in range(len(metrics))]
    angles += angles[:1]

    fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(polar=True))

    # Plot
    ax.plot(angles, values, linewidth=2, linestyle="solid", color="#1B5E20")
    ax.fill(angles, values, alpha=0.3, color="#1B5E20")

    # Labels
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(metrics)
    ax.set_ylim(0, 100)

    plt.title(f"Player Radar: {player_name}", size=14, y=1.1)
    plt.tight_layout()
    return fig

# Create radar for top player
metrics = ["xG", "shots", "pressures"]
fig = create_radar_chart(qualified, "A. Bonmati", metrics)
plt.show()

# Multi-player comparison
def compare_players_radar(data, players, metrics):
    """Compare multiple players on radar chart"""

    angles = [n / float(len(metrics)) * 2 * pi for n in range(len(metrics))]
    angles += angles[:1]

    fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(polar=True))

    colors = ["#1B5E20", "#FF6B35", "#4169E1", "#9932CC"]

    for i, player_name in enumerate(players):
        player = data[data["player"] == player_name]
        if len(player) == 0:
            continue

        values = [player[f"{m}_p90_pct"].values[0] for m in metrics]
        values += values[:1]

        ax.plot(angles, values, linewidth=2, label=player_name, color=colors[i])
        ax.fill(angles, values, alpha=0.1, color=colors[i])

    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(metrics)
    ax.set_ylim(0, 100)
    ax.legend(loc="upper right", bbox_to_anchor=(1.3, 1))

    plt.title("Player Comparison", size=14, y=1.1)
    return fig

# Compare top midfielders
top_midfielders = ["A. Bonmati", "L. Bronze", "A. Russo"]
fig = compare_players_radar(qualified, top_midfielders, metrics)
plt.show()

# Team Tactical Analysis - Women's Football
from statsbombpy import sb
import pandas as pd
import numpy as np

# Load match data
wwc_matches = sb.matches(competition_id=72, season_id=107)
all_events = []
for match_id in wwc_matches["match_id"]:
    events = sb.events(match_id=match_id)
    all_events.append(events)
events_df = pd.concat(all_events, ignore_index=True)

# Extract locations
events_df["x"] = events_df["location"].apply(lambda x: x[0] if isinstance(x, list) else None)
events_df["y"] = events_df["location"].apply(lambda x: x[1] if isinstance(x, list) else None)

# Pressing analysis
def analyze_pressing(events):
    """Analyze team pressing patterns"""
    pressures = events[events["type"] == "Pressure"].copy()

    # Define zones
    pressures["zone"] = pd.cut(
        pressures["x"],
        bins=[0, 40, 80, 120],
        labels=["Defensive", "Middle", "Attacking"]
    )

    # Team aggregation
    pressing_stats = pressures.groupby("team").agg({
        "id": "count",
        "zone": lambda x: (x == "Attacking").sum()
    }).reset_index()

    pressing_stats.columns = ["team", "total_pressures", "high_pressures"]
    pressing_stats["high_press_pct"] = (
        pressing_stats["high_pressures"] / pressing_stats["total_pressures"] * 100
    )

    return pressing_stats.sort_values("high_press_pct", ascending=False)

pressing_analysis = analyze_pressing(events_df)
print("Top Pressing Teams (High Press %):")
print(pressing_analysis[["team", "total_pressures", "high_press_pct"]].head(10))

# Build-up play analysis
def analyze_buildup(events):
    """Analyze team build-up patterns"""
    # Passes in defensive third
    passes = events[
        (events["type"] == "Pass") &
        (events["x"] < 40)
    ].copy()

    # Pass length
    passes["end_x"] = passes["pass_end_location"].apply(
        lambda x: x[0] if isinstance(x, list) else None
    )
    passes["pass_length"] = np.sqrt(
        (passes["end_x"] - passes["x"])**2
    )

    buildup_stats = passes.groupby("team").agg({
        "id": "count",
        "pass_length": ["mean", lambda x: (x < 15).sum(), lambda x: (x > 35).sum()]
    }).reset_index()

    buildup_stats.columns = ["team", "buildup_passes", "avg_length",
                             "short_passes", "long_passes"]

    buildup_stats["short_pct"] = buildup_stats["short_passes"] / buildup_stats["buildup_passes"] * 100
    buildup_stats["direct_pct"] = buildup_stats["long_passes"] / buildup_stats["buildup_passes"] * 100

    # Classify style
    buildup_stats["style"] = buildup_stats.apply(
        lambda x: "Possession" if x["short_pct"] > 60
                  else ("Direct" if x["direct_pct"] > 30 else "Balanced"),
        axis=1
    )

    return buildup_stats

buildup_analysis = analyze_buildup(events_df)
print("\nBuild-up Play Styles:")
print(buildup_analysis[["team", "short_pct", "direct_pct", "style"]])

# Recruitment Scouting System for Women's Football
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.metrics.pairwise import cosine_similarity

class WomensFootballScout:
    """Scouting and recruitment analytics for women's football"""

    def __init__(self):
        # Position-specific metric weights
        self.position_weights = {
            "Forward": {
                "xG_p90": 0.30, "shots_p90": 0.20,
                "dribbles_p90": 0.20, "pressures_p90": 0.15,
                "key_passes_p90": 0.15
            },
            "Midfielder": {
                "xG_p90": 0.15, "passes_p90": 0.25,
                "key_passes_p90": 0.20, "pressures_p90": 0.20,
                "interceptions_p90": 0.20
            },
            "Defender": {
                "interceptions_p90": 0.25, "tackles_p90": 0.25,
                "passes_p90": 0.20, "aerials_p90": 0.15,
                "pressures_p90": 0.15
            }
        }

        # League quality factors
        self.league_strength = {
            "WSL": 1.0,
            "Liga F": 1.0,
            "NWSL": 0.95,
            "D1 Feminine": 0.95,
            "Frauen-Bundesliga": 0.92,
            "Serie A Femminile": 0.88,
            "A-League Women": 0.80
        }

    def calculate_composite_score(self, player_data, position):
        """Calculate weighted composite score for position"""
        weights = self.position_weights.get(position, self.position_weights["Midfielder"])

        score = 0
        for metric, weight in weights.items():
            if metric in player_data.columns:
                # Use percentile ranking
                player_data[f"{metric}_pct"] = player_data[metric].rank(pct=True) * 100
                score += player_data[f"{metric}_pct"] * weight

        return score

    def adjust_for_league(self, data):
        """Adjust statistics for league quality"""
        data = data.copy()
        data["league_factor"] = data["league"].map(self.league_strength).fillna(0.85)
        data["adjusted_score"] = data["composite_score"] * data["league_factor"]
        return data

    def calculate_value_score(self, data):
        """Calculate player value considering age"""
        data = data.copy()

        # Age factors for women's football
        def age_factor(age):
            if age < 22: return 1.3    # High potential
            elif age < 25: return 1.2  # Rising
            elif age < 30: return 1.0  # Peak
            elif age < 33: return 0.8  # Declining
            else: return 0.6           # Veterans

        data["age_factor"] = data["age"].apply(age_factor)
        data["value_score"] = data["composite_score"] * data["age_factor"]
        return data

    def find_similar_players(self, target_name, all_players, features, n=10):
        """Find players similar to target using cosine similarity"""
        # Prepare feature matrix
        X = all_players[features].fillna(0)
        scaler = StandardScaler()
        X_scaled = scaler.fit_transform(X)

        # Find target index
        target_idx = all_players[all_players["player"] == target_name].index[0]
        target_vector = X_scaled[target_idx].reshape(1, -1)

        # Calculate similarities
        similarities = cosine_similarity(target_vector, X_scaled)[0]
        all_players["similarity"] = similarities

        return all_players.nlargest(n + 1, "similarity").iloc[1:]  # Exclude self

# Usage example
scout = WomensFootballScout()

# Calculate scores for forwards
# forward_data = scout.calculate_composite_score(player_stats, "Forward")
# adjusted_data = scout.adjust_for_league(forward_data)
# valued_data = scout.calculate_value_score(adjusted_data)

print("Scouting system initialized")
print(f"Positions: {list(scout.position_weights.keys())}")
print(f"Leagues: {list(scout.league_strength.keys())}")

# Python: Physical performance analysis for women's football
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class PhysicalBenchmarks:
    """Physical performance benchmarks for women's football."""

    # Position benchmarks (per 90 minutes)
    position_benchmarks = {
        "GK": {"total_distance": 5500, "high_speed": 100, "sprint": 30, "accelerations": 15},
        "CB": {"total_distance": 9500, "high_speed": 300, "sprint": 80, "accelerations": 35},
        "FB": {"total_distance": 10800, "high_speed": 600, "sprint": 150, "accelerations": 50},
        "CM": {"total_distance": 11200, "high_speed": 500, "sprint": 120, "accelerations": 45},
        "AM": {"total_distance": 10500, "high_speed": 550, "sprint": 140, "accelerations": 55},
        "W": {"total_distance": 10200, "high_speed": 650, "sprint": 180, "accelerations": 60},
        "ST": {"total_distance": 9800, "high_speed": 500, "sprint": 130, "accelerations": 45}
    }

    # Speed zones (km/h) - women's specific
    speed_zones = {
        1: (0, 7, "Walking"),
        2: (7, 13, "Jogging"),
        3: (13, 18, "Running"),
        4: (18, 23, "High-speed running"),
        5: (23, 30, "Sprinting")
    }

class WomensPhysicalAnalyzer:
    """Analyze physical performance in women's football."""

    def __init__(self):
        self.benchmarks = PhysicalBenchmarks()

    def analyze_match_performance(self, player_data: pd.DataFrame) -> pd.DataFrame:
        """Compare player physical output to benchmarks."""

        df = player_data.copy()

        # Get benchmarks for each position
        df["benchmark_distance"] = df["position"].map(
            lambda x: self.benchmarks.position_benchmarks.get(x, {}).get("total_distance", 10000)
        )
        df["benchmark_hsd"] = df["position"].map(
            lambda x: self.benchmarks.position_benchmarks.get(x, {}).get("high_speed", 500)
        )
        df["benchmark_sprint"] = df["position"].map(
            lambda x: self.benchmarks.position_benchmarks.get(x, {}).get("sprint", 100)
        )

        # Calculate percentages
        df["distance_pct"] = df["total_distance"] / df["benchmark_distance"] * 100
        df["hsd_pct"] = df["high_speed_distance"] / df["benchmark_hsd"] * 100
        df["sprint_pct"] = df["sprint_distance"] / df["benchmark_sprint"] * 100

        # Overall physical score
        df["physical_score"] = (df["distance_pct"] + df["hsd_pct"] + df["sprint_pct"]) / 3

        # Performance classification
        df["performance_level"] = pd.cut(
            df["physical_score"],
            bins=[0, 80, 90, 100, 110, float("inf")],
            labels=["Underperforming", "Below Average", "Average", "Above Average", "Exceptional"]
        )

        return df

    def analyze_cycle_impact(self, physical_data: pd.DataFrame,
                            cycle_data: pd.DataFrame) -> pd.DataFrame:
        """Analyze performance variation across menstrual cycle phases."""

        # Merge datasets
        combined = physical_data.merge(cycle_data, on=["player_id", "date"], how="left")

        # Define cycle phases
        def get_phase(day):
            if pd.isna(day):
                return "Unknown"
            if day <= 5:
                return "Menstruation"
            elif day <= 14:
                return "Follicular"
            elif day <= 21:
                return "Ovulation"
            else:
                return "Luteal"

        combined["cycle_phase"] = combined["day_in_cycle"].apply(get_phase)

        # Aggregate by phase
        phase_analysis = combined.groupby(["player_id", "cycle_phase"]).agg({
            "total_distance": "mean",
            "high_speed_distance": "mean",
            "sprint_distance": "mean",
            "rpe": "mean"  # Rating of Perceived Exertion
        }).reset_index()

        return phase_analysis

    def calculate_acl_risk(self, player_data: pd.DataFrame) -> pd.DataFrame:
        """Calculate ACL injury risk factors."""

        df = player_data.copy()

        # Risk factors
        df["fatigue_risk"] = np.clip(
            df["acute_load"] / df["chronic_load"] - 1, 0, 1
        )

        df["asymmetry_risk"] = np.abs(
            df["left_leg_load"] - df["right_leg_load"]
        ) / df["total_load"]

        df["deceleration_risk"] = df["high_decelerations"] / 50

        # Age factor (higher risk after 25)
        df["age_risk"] = np.where(df["age"] > 25, 0.2, 0)

        # Composite score
        df["acl_risk_score"] = (
            0.3 * df["fatigue_risk"] +
            0.3 * df["asymmetry_risk"] +
            0.2 * np.clip(df["deceleration_risk"], 0, 1) +
            0.2 * df["age_risk"]
        )

        df["risk_level"] = pd.cut(
            df["acl_risk_score"],
            bins=[0, 0.4, 0.7, 1.0],
            labels=["Low", "Moderate", "High"]
        )

        return df

    def training_load_recommendations(self, player_data: pd.DataFrame) -> Dict:
        """Generate training load recommendations."""

        recommendations = {}

        for _, player in player_data.iterrows():
            player_id = player["player_id"]

            # ACWR (Acute:Chronic Workload Ratio)
            acwr = player["acute_load"] / player["chronic_load"] if player["chronic_load"] > 0 else 0

            if acwr > 1.5:
                recommendation = "Reduce load - high injury risk zone"
            elif acwr > 1.3:
                recommendation = "Caution - approaching high risk"
            elif acwr < 0.8:
                recommendation = "Can increase load - in safe zone"
            else:
                recommendation = "Maintain current load - optimal zone"

            recommendations[player_id] = {
                "acwr": acwr,
                "recommendation": recommendation,
                "cycle_phase": player.get("cycle_phase", "Unknown")
            }

        return recommendations

# Example usage
analyzer = WomensPhysicalAnalyzer()
print("Physical performance analyzer initialized")
print(f"Position benchmarks available: {list(analyzer.benchmarks.position_benchmarks.keys())}")

# Python: Youth development pathway analysis
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Tuple
from sklearn.preprocessing import StandardScaler

@dataclass
class DevelopmentPathway:
    """Define development pathway stages for women's football."""

    stages = {
        "Foundation": {"age_range": (8, 11), "focus": "Technical fundamentals"},
        "Talent": {"age_range": (12, 14), "focus": "Tactical awareness"},
        "Youth": {"age_range": (15, 17), "focus": "Position specialization"},
        "Senior Transition": {"age_range": (18, 21), "focus": "First team integration"},
        "Elite": {"age_range": (22, 35), "focus": "Peak performance"}
    }

    @staticmethod
    def get_stage(age: int) -> str:
        if age < 12:
            return "Foundation"
        elif age < 15:
            return "Talent"
        elif age < 18:
            return "Youth"
        elif age < 22:
            return "Senior Transition"
        else:
            return "Elite"

class YouthDevelopmentAnalyzer:
    """Analytics for youth player development."""

    def __init__(self):
        self.pathway = DevelopmentPathway()
        self.scaler = StandardScaler()

    def track_development(self, player_history: pd.DataFrame) -> pd.DataFrame:
        """Track player development trajectory over time."""

        df = player_history.sort_values("date").copy()

        # Technical growth rate
        df["technical_growth"] = df["technical_score"].pct_change()

        # Physical development tracking
        df["height_velocity"] = df["height"].diff()

        # Performance trend (rolling average)
        df["performance_trend"] = df["match_rating"].rolling(10, min_periods=3).mean()

        # Current development phase
        df["development_phase"] = df["age"].apply(self.pathway.get_stage)

        # Growth spurt detection
        df["growth_spurt"] = df["height_velocity"] > 0.5  # >0.5cm per measurement period

        return df

    def identify_talent(self, youth_data: pd.DataFrame,
                       age_group: str) -> pd.DataFrame:
        """Identify high-potential players within age group."""

        # Filter to age group
        group_data = youth_data[youth_data["age_group"] == age_group].copy()

        if len(group_data) < 5:
            return group_data

        # Metrics to evaluate
        metrics = ["technical_score", "physical_score", "tactical_score"]

        # Standardize within age group
        group_data[metrics] = self.scaler.fit_transform(group_data[metrics])

        # Composite potential score (weighted average of z-scores)
        group_data["potential_score"] = (
            group_data["technical_score"] * 0.4 +
            group_data["physical_score"] * 0.3 +
            group_data["tactical_score"] * 0.3
        )

        # Classification
        group_data["talent_tier"] = pd.cut(
            group_data["potential_score"],
            bins=[-np.inf, 0, 1, 2, np.inf],
            labels=["Needs Development", "Developing", "High Potential", "Elite Prospect"]
        )

        return group_data.sort_values("potential_score", ascending=False)

    def adjust_for_maturity(self, player_data: pd.DataFrame) -> pd.DataFrame:
        """Adjust metrics for biological maturity timing."""

        df = player_data.copy()

        # Bio-banding: estimate biological vs chronological age
        df["bio_age_offset"] = df["estimated_bio_age"] - df["chronological_age"]

        # Classify maturity timing
        df["maturity_status"] = pd.cut(
            df["bio_age_offset"],
            bins=[-np.inf, -1, 1, np.inf],
            labels=["Late Developer", "On-time", "Early Developer"]
        )

        # Adjust physical metrics
        df["adjusted_speed"] = df["max_speed"] - (df["bio_age_offset"] * 0.5)
        df["adjusted_strength"] = df["strength_score"] - (df["bio_age_offset"] * 2)

        # Flag late developers (often overlooked but may have higher ceiling)
        df["late_developer_flag"] = df["maturity_status"] == "Late Developer"

        return df

    def predict_dropout_risk(self, player_data: pd.DataFrame) -> pd.DataFrame:
        """Predict risk of player dropping out of pathway."""

        df = player_data.copy()

        # Engagement score
        df["engagement_score"] = (
            df["attendance_rate"] * 0.3 +
            df["enjoyment_rating"] * 0.3 +
            df["progress_rating"] * 0.4
        )

        # Risk classification
        df["dropout_risk"] = pd.cut(
            df["engagement_score"],
            bins=[0, 0.4, 0.6, 1.0],
            labels=["High", "Moderate", "Low"]
        )

        # Early warning indicators
        df["declining_engagement"] = df["engagement_score"] < df["engagement_score"].shift(3)

        return df

    def generate_development_report(self, player_id: str,
                                    history: pd.DataFrame) -> Dict:
        """Generate comprehensive development report for player."""

        player_history = history[history["player_id"] == player_id]

        if len(player_history) == 0:
            return {"error": "Player not found"}

        latest = player_history.iloc[-1]
        earliest = player_history.iloc[0]

        return {
            "player_id": player_id,
            "current_age": latest["age"],
            "current_phase": self.pathway.get_stage(latest["age"]),
            "time_in_program": (latest["date"] - earliest["date"]).days / 365,
            "technical_improvement": (
                latest["technical_score"] - earliest["technical_score"]
            ) / earliest["technical_score"] * 100,
            "physical_improvement": (
                latest["physical_score"] - earliest["physical_score"]
            ) / earliest["physical_score"] * 100,
            "current_talent_tier": latest.get("talent_tier", "Unknown"),
            "maturity_status": latest.get("maturity_status", "Unknown"),
            "dropout_risk": latest.get("dropout_risk", "Unknown"),
            "recommendation": self._generate_recommendation(latest)
        }

    def _generate_recommendation(self, player_data: pd.Series) -> str:
        """Generate development recommendation."""

        if player_data.get("talent_tier") == "Elite Prospect":
            return "Consider accelerated pathway to senior team"
        elif player_data.get("maturity_status") == "Late Developer":
            return "Monitor closely - potential for late development surge"
        elif player_data.get("dropout_risk") == "High":
            return "Intervention needed - focus on engagement and enjoyment"
        else:
            return "Continue current development plan"

# Example usage
analyzer = YouthDevelopmentAnalyzer()
print("Youth development analyzer initialized")
print(f"Development stages: {list(analyzer.pathway.stages.keys())}")

# Python: International vs. Club performance analysis
import pandas as pd
import numpy as np
from typing import Dict, List

class InternationalAnalyzer:
    """Analyze international vs. club performance."""

    def __init__(self, fifa_rankings: pd.DataFrame = None):
        self.rankings = fifa_rankings

    def compare_contexts(self, player_data: pd.DataFrame) -> pd.DataFrame:
        """Compare player performance in club vs. international."""

        # Aggregate by context
        context_stats = player_data.groupby(["player_id", "context"]).agg({
            "match_id": "count",
            "goals": "sum",
            "assists": "sum",
            "xG": "sum",
            "xA": "sum",
            "minutes": "sum",
            "rating": "mean"
        }).reset_index()

        context_stats.columns = ["player_id", "context", "matches", "goals",
                                 "assists", "xG", "xA", "minutes", "avg_rating"]

        # Per 90 metrics
        context_stats["goals_p90"] = context_stats["goals"] / context_stats["minutes"] * 90
        context_stats["xG_p90"] = context_stats["xG"] / context_stats["minutes"] * 90
        context_stats["xA_p90"] = context_stats["xA"] / context_stats["minutes"] * 90

        # Pivot to compare
        comparison = context_stats.pivot(
            index="player_id",
            columns="context",
            values=["goals_p90", "xG_p90", "avg_rating"]
        )

        comparison.columns = ["_".join(col) for col in comparison.columns]
        comparison = comparison.reset_index()

        # Calculate differences
        if "goals_p90_international" in comparison.columns and "goals_p90_club" in comparison.columns:
            comparison["goal_difference"] = (
                comparison["goals_p90_international"] - comparison["goals_p90_club"]
            )

            comparison["player_type"] = np.where(
                comparison["goal_difference"] > 0.1, "International Performer",
                np.where(comparison["goal_difference"] < -0.1, "Club Performer", "Consistent")
            )

        return comparison

    def adjust_for_opponent(self, player_data: pd.DataFrame) -> pd.DataFrame:
        """Adjust statistics for opponent quality."""

        if self.rankings is None:
            return player_data

        df = player_data.merge(
            self.rankings[["team", "fifa_rank"]],
            left_on="opponent",
            right_on="team",
            how="left"
        )

        # Opponent factor based on FIFA ranking
        def get_opponent_factor(rank):
            if pd.isna(rank):
                return 0.9
            if rank <= 10:
                return 1.5
            elif rank <= 25:
                return 1.2
            elif rank <= 50:
                return 1.0
            elif rank <= 100:
                return 0.8
            else:
                return 0.6

        df["opponent_factor"] = df["fifa_rank"].apply(get_opponent_factor)
        df["adjusted_xG"] = df["xG"] * df["opponent_factor"]
        df["adjusted_goals"] = df["goals"] * df["opponent_factor"]

        return df

    def analyze_tournament(self, tournament_data: pd.DataFrame) -> pd.DataFrame:
        """Analyze tournament-specific performance."""

        # Define stage importance
        stage_map = {
            "Group": 1,
            "Round of 16": 2,
            "Quarter-final": 3,
            "Semi-final": 4,
            "Final": 5
        }

        df = tournament_data.copy()
        df["stage_weight"] = df["match_type"].map(stage_map).fillna(1)

        # Aggregate by player
        player_stats = df.groupby(["player_id", "player_name"]).agg({
            "goals": "sum",
            "xG": "sum",
            "rating": "mean"
        }).reset_index()

        # Knockout stage performance
        knockout = df[df["stage_weight"] >= 2].groupby("player_id").agg({
            "goals": "sum",
            "rating": "mean"
        }).reset_index()
        knockout.columns = ["player_id", "knockout_goals", "knockout_rating"]

        # Group stage performance
        group = df[df["stage_weight"] == 1].groupby("player_id").agg({
            "rating": "mean"
        }).reset_index()
        group.columns = ["player_id", "group_rating"]

        # Merge
        player_stats = player_stats.merge(knockout, on="player_id", how="left")
        player_stats = player_stats.merge(group, on="player_id", how="left")

        # Clutch factor
        player_stats["clutch_factor"] = (
            player_stats["knockout_rating"].fillna(0) -
            player_stats["group_rating"].fillna(0)
        )

        return player_stats.sort_values("clutch_factor", ascending=False)

    def analyze_senior_pathway(self, youth_data: pd.DataFrame) -> pd.DataFrame:
        """Analyze pathway from youth to senior international team."""

        pathway = youth_data.groupby("player_id").agg({
            "age": ["min", "max"],
            "team_level": lambda x: {
                "u17_caps": (x == "U17").sum(),
                "u19_caps": (x == "U19").sum(),
                "u21_caps": (x == "U21").sum(),
                "senior_caps": (x == "Senior").sum()
            }
        }).reset_index()

        # Flatten
        pathway.columns = ["player_id", "first_age", "last_age", "cap_counts"]

        # Extract cap counts
        pathway["u17_caps"] = pathway["cap_counts"].apply(lambda x: x["u17_caps"])
        pathway["u19_caps"] = pathway["cap_counts"].apply(lambda x: x["u19_caps"])
        pathway["senior_caps"] = pathway["cap_counts"].apply(lambda x: x["senior_caps"])

        # Made senior team?
        pathway["made_senior"] = pathway["senior_caps"] > 0

        # Progression rate
        pathway["progression_rate"] = np.where(
            pathway["made_senior"],
            1 / (pathway["last_age"] - pathway["first_age"] + 1),
            0
        )

        return pathway

# Example usage
analyzer = InternationalAnalyzer()
print("International vs. Club analyzer initialized")

# Analyzing Growth of Women's Football
import pandas as pd
import matplotlib.pyplot as plt

# Sample data: Growth metrics over time
growth_data = pd.DataFrame({
    "year": [2019, 2020, 2021, 2022, 2023] * 2,
    "metric": ["WSL Average Attendance"] * 5 + ["NWSL Average Attendance"] * 5,
    "value": [3048, 2847, 3523, 6744, 8134, 7337, 0, 7843, 10628, 11276]
})

# Filter out COVID year
growth_data = growth_data[growth_data["value"] > 0]

# Calculate growth rates
def calculate_growth(group):
    group = group.sort_values("year")
    group["yoy_growth"] = group["value"].pct_change() * 100
    group["cumulative_growth"] = (
        (group["value"] - group["value"].iloc[0]) / group["value"].iloc[0] * 100
    )
    return group

growth_analysis = growth_data.groupby("metric").apply(calculate_growth).reset_index(drop=True)

print("Growth Analysis:")
print(growth_analysis)

# Visualization
fig, ax = plt.subplots(figsize=(10, 6))

for metric in growth_data["metric"].unique():
    data = growth_data[growth_data["metric"] == metric]
    ax.plot(data["year"], data["value"], marker="o",
            linewidth=2, markersize=8, label=metric)

ax.set_xlabel("Year")
ax.set_ylabel("Average Attendance")
ax.set_title("Growth of Women's Football Attendance")
ax.legend()
ax.grid(True, alpha=0.3)

# Format y-axis
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: format(int(x), ",")))

plt.tight_layout()
plt.show()

# Investment and coverage growth
investment_data = pd.DataFrame({
    "category": ["Broadcast Deals (M)", "Club Budgets (avg M)",
                 "Data Coverage (leagues)", "Analytics Staff (per club)"],
    "y2019": [5, 2, 5, 0.5],
    "y2023": [50, 8, 15, 2.5]
})

investment_data["growth_pct"] = (
    (investment_data["y2023"] - investment_data["y2019"]) /
    investment_data["y2019"] * 100
)

print("\nWomen's Football Growth 2019-2023:")
print(investment_data.to_string(index=False))