backend commit

.env

@@ -0,0 +1 @@
+GROQ_API_KEY=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

Dockerfile

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire app directory into the container
+COPY app/ .
+
+# Expose port 8000 for the FastAPI app
+EXPOSE 8000
+
+# Command to run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

app/data/country_codes.json

@@ -0,0 +1,175 @@
+{
+    "Afghanistan": "af",
+    "Albania": "al",
+    "Algeria": "dz",
+    "Andorra": "ad",
+    "Angola": "ao",
+    "Argentina": "ar",
+    "Armenia": "am",
+    "Australia": "au",
+    "Austria": "at",
+    "Azerbaijan": "az",
+    "Bahrain": "bh",
+    "Bangladesh": "bd",
+    "Belarus": "by",
+    "Belgium": "be",
+    "Benin": "bj",
+    "Bhutan": "bt",
+    "Bolivia": "bo",
+    "Bosnia and Herzegovina": "ba",
+    "Botswana": "bw",
+    "Brazil": "br",
+    "Bulgaria": "bg",
+    "Burkina Faso": "bf",
+    "Burundi": "bi",
+    "Cameroon": "cm",
+    "Canada": "ca",
+    "Cape Verde": "cv",
+    "Central African Republic": "cf",
+    "Chad": "td",
+    "Chile": "cl",
+    "China": "cn",
+    "Colombia": "co",
+    "Comoros": "km",
+    "Congo": "cg",
+    "Costa Rica": "cr",
+    "Croatia": "hr",
+    "Cuba": "cu",
+    "Cyprus": "cy",
+    "Czech Republic": "cz",
+    "Denmark": "dk",
+    "Djibouti": "dj",
+    "DR Congo": "cd",
+    "Ecuador": "ec",
+    "Egypt": "eg",
+    "El Salvador": "sv",
+    "England": "gb-eng",
+    "Equatorial Guinea": "gq",
+    "Eritrea": "er",
+    "Estonia": "ee",
+    "Eswatini": "sz",
+    "Ethiopia": "et",
+    "Fiji": "fj",
+    "Finland": "fi",
+    "France": "fr",
+    "Gabon": "ga",
+    "Gambia": "gm",
+    "Georgia": "ge",
+    "Germany": "de",
+    "Ghana": "gh",
+    "Greece": "gr",
+    "Guatemala": "gt",
+    "Guinea": "gn",
+    "Guinea-Bissau": "gw",
+    "Guyana": "gy",
+    "Haiti": "ht",
+    "Honduras": "hn",
+    "Hungary": "hu",
+    "Iceland": "is",
+    "India": "in",
+    "Indonesia": "id",
+    "Iran": "ir",
+    "Iraq": "iq",
+    "Ireland": "ie",
+    "Israel": "il",
+    "Italy": "it",
+    "Ivory Coast": "ci",
+    "Jamaica": "jm",
+    "Japan": "jp",
+    "Jordan": "jo",
+    "Kazakhstan": "kz",
+    "Kenya": "ke",
+    "Kosovo": "xk",
+    "Kuwait": "kw",
+    "Kyrgyzstan": "kg",
+    "Laos": "la",
+    "Latvia": "lv",
+    "Lebanon": "lb",
+    "Lesotho": "ls",
+    "Liberia": "lr",
+    "Libya": "ly",
+    "Liechtenstein": "li",
+    "Lithuania": "lt",
+    "Luxembourg": "lu",
+    "Madagascar": "mg",
+    "Malawi": "mw",
+    "Malaysia": "my",
+    "Maldives": "mv",
+    "Mali": "ml",
+    "Malta": "mt",
+    "Mauritania": "mr",
+    "Mauritius": "mu",
+    "Mexico": "mx",
+    "Moldova": "md",
+    "Monaco": "mc",
+    "Mongolia": "mn",
+    "Montenegro": "me",
+    "Morocco": "ma",
+    "Mozambique": "mz",
+    "Myanmar": "mm",
+    "Namibia": "na",
+    "Nepal": "np",
+    "Netherlands": "nl",
+    "New Zealand": "nz",
+    "Nicaragua": "ni",
+    "Niger": "ne",
+    "Nigeria": "ng",
+    "North Korea": "kp",
+    "North Macedonia": "mk",
+    "Norway": "no",
+    "Oman": "om",
+    "Pakistan": "pk",
+    "Palestine": "ps",
+    "Panama": "pa",
+    "Papua New Guinea": "pg",
+    "Paraguay": "py",
+    "Peru": "pe",
+    "Philippines": "ph",
+    "Poland": "pl",
+    "Portugal": "pt",
+    "Qatar": "qa",
+    "Romania": "ro",
+    "Russia": "ru",
+    "Rwanda": "rw",
+    "San Marino": "sm",
+    "Saudi Arabia": "sa",
+    "Scotland": "gb-sct",
+    "Senegal": "sn",
+    "Serbia": "rs",
+    "Seychelles": "sc",
+    "Sierra Leone": "sl",
+    "Singapore": "sg",
+    "Slovakia": "sk",
+    "Slovenia": "si",
+    "Somalia": "so",
+    "South Africa": "za",
+    "South Korea": "kr",
+    "South Sudan": "ss",
+    "Spain": "es",
+    "Sri Lanka": "lk",
+    "Sudan": "sd",
+    "Suriname": "sr",
+    "Sweden": "se",
+    "Switzerland": "ch",
+    "Syria": "sy",
+    "Tajikistan": "tj",
+    "Tanzania": "tz",
+    "Thailand": "th",
+    "Togo": "tg",
+    "Trinidad and Tobago": "tt",
+    "Tunisia": "tn",
+    "Turkey": "tr",
+    "Turkmenistan": "tm",
+    "Uganda": "ug",
+    "Ukraine": "ua",
+    "United Arab Emirates": "ae",
+    "United States": "us",
+    "Uruguay": "uy",
+    "Uzbekistan": "uz",
+    "Venezuela": "ve",
+    "Vietnam": "vn",
+    "Wales": "gb-wls",
+    "Yemen": "ye",
+    "Zambia": "zm",
+    "Zimbabwe": "zw"
+}

app/data/model/train_model.py

@@ -0,0 +1,95 @@
+# model/train_model.py
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression, LinearRegression
+from sklearn.preprocessing import LabelEncoder
+import joblib
+import os
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load datasets
+try:
+    matches_df = pd.read_csv('data/results.csv')
+except FileNotFoundError as e:
+    logger.error(f"Dataset not found: {e}")
+    raise
+
+matches_df['home_score'] = pd.to_numeric(matches_df['home_score'], errors='coerce').fillna(0)
+matches_df['away_score'] = pd.to_numeric(matches_df['away_score'], errors='coerce').fillna(0)
+
+# Define the training function
+def train_and_save_models():
+    # --- Prepare Data ---
+    # Create a symmetric outcome: 0 for team1 win, 1 for draw, 2 for team2 win
+    def get_match_outcome(row):
+        if row['home_score'] > row['away_score']:
+            return 0 if row['home_team'] < row['away_team'] else 2
+        elif row['home_score'] < row['away_score']:
+            return 2 if row['home_team'] < row['away_team'] else 0
+        else:
+            return 1
+
+    matches_df['outcome'] = matches_df.apply(get_match_outcome, axis=1)
+    
+    # Sort teams alphabetically to ensure consistency
+    matches_df['team1'] = matches_df.apply(lambda x: min(x['home_team'], x['away_team']), axis=1)
+    matches_df['team2'] = matches_df.apply(lambda x: max(x['home_team'], x['away_team']), axis=1)
+    
+    # Get all unique team names from both home_team and away_team
+    all_teams = pd.concat([matches_df['home_team'], matches_df['away_team']]).unique()
+    
+    # Encode team names with a single LabelEncoder fitted on all teams
+    le_outcome = LabelEncoder()
+    le_outcome.fit(all_teams)  # Fit on all unique teams
+    
+    # --- Logistic Regression for Match Outcome ---
+    X_outcome = pd.DataFrame({
+        'team1': le_outcome.transform(matches_df['team1']),
+        'team2': le_outcome.transform(matches_df['team2'])
+    })
+    y_outcome = matches_df['outcome']
+    
+    # Split data and train Logistic Regression model
+    X_train_outcome, _, y_train_outcome, _ = train_test_split(X_outcome, y_outcome, test_size=0.2, random_state=42)
+    logistic_model = LogisticRegression(multi_class='multinomial', max_iter=1000)
+    logistic_model.fit(X_train_outcome, y_train_outcome)
+    
+    # --- Linear Regression for Goal Prediction ---
+    X_goals = pd.DataFrame({
+        'team1': le_outcome.transform(matches_df['team1']),
+        'team2': le_outcome.transform(matches_df['team2'])
+    })
+    
+    # Targets: home_score and away_score as separate predictions
+    y_team1_goals = matches_df['home_score']  # Goals scored by team1 (home team in original data)
+    y_team2_goals = matches_df['away_score']  # Goals scored by team2 (away team in original data)
+    
+    # Split data for goal prediction
+    X_train_goals, _, y_train_team1_goals, _, y_train_team2_goals, _ = train_test_split(
+        X_goals, y_team1_goals, y_team2_goals, test_size=0.2, random_state=42
+    )
+    
+    # Train Linear Regression models for each team's goals
+    linear_model_team1 = LinearRegression()
+    linear_model_team2 = LinearRegression()
+    
+    linear_model_team1.fit(X_train_goals, y_train_team1_goals)
+    linear_model_team2.fit(X_train_goals, y_train_team2_goals)
+    
+    # Ensure the model directory exists
+    os.makedirs('model', exist_ok=True)
+    
+    # Save all models and the label encoder
+    joblib.dump(logistic_model, 'model/logistic_regression_model.pkl')
+    joblib.dump(linear_model_team1, 'model/linear_regression_team1_goals.pkl')
+    joblib.dump(linear_model_team2, 'model/linear_regression_team2_goals.pkl')
+    joblib.dump(le_outcome, 'model/label_encoder.pkl')
+    
+    logger.info("Logistic Regression and Linear Regression models, along with LabelEncoder, saved successfully.")
+
+if __name__ == "__main__":
+    train_and_save_models()

app/main.py

@@ -0,0 +1,441 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import pandas as pd
+import uvicorn
+import plotly.graph_objects as go
+import logging
+import joblib
+import numpy as np
+import os
+import json
+from groq import Groq
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+if not GROQ_API_KEY:
+    raise Exception("GROQ_API_KEY not found in environment variables.")
+
+client = Groq(api_key=GROQ_API_KEY)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# Enable CORS to allow frontend communication
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust to specific frontend URL in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Load datasets and country codes
+try:
+    matches_df = pd.read_csv('data/results.csv')
+    goals_df = pd.read_csv('data/goalscorers.csv')
+    with open('data/country_codes.json', 'r') as f:
+        COUNTRY_CODE_MAP = json.load(f)
+except FileNotFoundError as e:
+    logger.error(f"File not found: {e}")
+    raise HTTPException(status_code=500, detail="Data files not found or inaccessible")
+except pd.errors.EmptyDataError as e:
+    logger.error(f"CSV files are empty: {e}")
+    raise HTTPException(status_code=500, detail="Data files are empty or invalid")
+
+matches_df['home_score'] = pd.to_numeric(matches_df['home_score'], errors='coerce').fillna(0)
+matches_df['away_score'] = pd.to_numeric(matches_df['away_score'], errors='coerce').fillna(0)
+
+np.random.seed(42)
+goals_df['x_coord'] = np.where(
+    goals_df['team'] == goals_df['home_team'],
+    np.random.uniform(80, 100, len(goals_df)).round(),
+    np.random.uniform(0, 20, len(goals_df)).round()
+)
+goals_df['y_coord'] = np.random.uniform(20, 80, len(goals_df)).round()
+
+teams = set(matches_df['home_team'].unique()).union(set(matches_df['away_team'].unique()))
+players = sorted([str(scorer) for scorer in goals_df['scorer'].dropna().unique() if pd.notna(scorer)])
+
+try:
+    logistic_model = joblib.load('model/logistic_regression_model.pkl')
+    linear_model_team1 = joblib.load('model/linear_regression_team1_goals.pkl')
+    linear_model_team2 = joblib.load('model/linear_regression_team2_goals.pkl')
+    le = joblib.load('model/label_encoder.pkl')
+    logger.info("Models loaded successfully.")
+except FileNotFoundError as e:
+    logger.error(f"Model files not found: {e}")
+    raise HTTPException(status_code=500, detail="Trained model files not found.")
+
+def summarize_with_groq(text):
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant that provides concise summaries."},
+                {"role": "user", "content": f"Summarize the following text:\n\n{text}"}
+            ],
+            model="llama-3.3-70b-versatile",
+            max_tokens=150
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as e:
+        logger.error(f"Error summarizing with Groq: {e}")
+        return "Summary unavailable due to an error."
+
+def get_team_stats(team_name):
+    home_matches = matches_df[matches_df['home_team'] == team_name]
+    away_matches = matches_df[matches_df['away_team'] == team_name]
+    
+    if home_matches.empty and away_matches.empty:
+        return {
+            "total_matches": 0,
+            "wins": 0,
+            "losses": 0,
+            "draws": 0,
+            "home_matches_played": 0,
+            "away_matches_played": 0,
+            "tournament_performance": {},
+            "country_code": COUNTRY_CODE_MAP.get(team_name, "unknown")
+        }
+    
+    total_matches = len(home_matches) + len(away_matches)
+    wins = len(home_matches[home_matches['home_score'] > home_matches['away_score']]) + \
+           len(away_matches[away_matches['away_score'] > away_matches['home_score']])
+    losses = len(home_matches[home_matches['home_score'] < home_matches['away_score']]) + \
+             len(away_matches[away_matches['away_score'] < away_matches['home_score']])
+    draws = len(home_matches[home_matches['home_score'] == home_matches['away_score']]) + \
+            len(away_matches[away_matches['away_score'] == away_matches['home_score']])
+    
+    all_matches = pd.concat([home_matches, away_matches])
+    tournament_stats = {}
+    
+    for tournament in all_matches['tournament'].unique():
+        tourn_matches = all_matches[all_matches['tournament'] == tournament]
+        tourn_wins = len(tourn_matches[
+            ((tourn_matches['home_team'] == team_name) & (tourn_matches['home_score'] > tourn_matches['away_score'])) |
+            ((tourn_matches['away_team'] == team_name) & (tourn_matches['away_score'] > tourn_matches['home_score']))
+        ])
+        tourn_losses = len(tourn_matches[
+            ((tourn_matches['home_team'] == team_name) & (tourn_matches['home_score'] < tourn_matches['away_score'])) |
+            ((tourn_matches['away_team'] == team_name) & (tourn_matches['away_score'] < tourn_matches['home_score']))
+        ])
+        tourn_draws = len(tourn_matches[tourn_matches['home_score'] == tourn_matches['away_score']])
+        tourn_total = tourn_wins + tourn_losses + tourn_draws
+        tournament_stats[tournament] = {
+            "matches_played": tourn_total,
+            "wins": tourn_wins,
+            "losses": tourn_losses,
+            "draws": tourn_draws,
+            "win_percentage": round((tourn_wins / tourn_total * 100), 2) if tourn_total > 0 else 0.0
+        }
+    
+    return {
+        "total_matches": total_matches,
+        "wins": wins,
+        "losses": losses,
+        "draws": draws,
+        "home_matches_played": len(home_matches),
+        "away_matches_played": len(away_matches),
+        "tournament_performance": tournament_stats,
+        "country_code": COUNTRY_CODE_MAP.get(team_name, "unknown")
+    }
+
+def get_match_goalscorers(date, home_team, away_team):
+    match_goals = goals_df[(goals_df['date'] == date) & 
+                          (goals_df['home_team'] == home_team) & 
+                          (goals_df['away_team'] == away_team)]
+    return match_goals[['scorer', 'minute', 'team', 'own_goal', 'penalty']].to_dict('records')
+
+def get_head_to_head_stats(team1, team2, num_matches=5):
+    matches = matches_df[((matches_df['home_team'] == team1) & (matches_df['away_team'] == team2)) | 
+                        ((matches_df['home_team'] == team2) & (matches_df['away_team'] == team1))]
+    
+    if matches.empty:
+        return {"total_matches": 0, f"{team1}_wins": 0, f"{team2}_wins": 0, "draws": 0,
+                f"{team1}_goals": 0, f"{team2}_goals": 0, "goal_difference": "Even",
+                "last_matches": [], "chart": None}
+    
+    total_matches = len(matches)
+    team1_wins = len(matches[((matches['home_team'] == team1) & (matches['home_score'] > matches['away_score'])) |
+                            ((matches['away_team'] == team1) & (matches['away_score'] > matches['home_score']))])
+    team2_wins = len(matches[((matches['home_team'] == team2) & (matches['home_score'] > matches['away_score'])) |
+                            ((matches['away_team'] == team2) & (matches['away_score'] > matches['home_score']))])
+    draws = len(matches[matches['home_score'] == matches['away_score']])
+    team1_goals = matches[matches['home_team'] == team1]['home_score'].sum() + \
+                 matches[matches['away_team'] == team1]['away_score'].sum()
+    team2_goals = matches[matches['home_team'] == team2]['home_score'].sum() + \
+                 matches[matches['away_team'] == team2]['away_score'].sum()
+    
+    goal_diff = team1_goals - team2_goals
+    goal_difference_str = f"{team1} +{int(goal_diff)}" if goal_diff > 0 else \
+                         f"{team2} +{int(abs(goal_diff))}" if goal_diff < 0 else "Even"
+    
+    last_n_matches = matches.tail(num_matches)
+    last_n_results = []
+    for _, match in last_n_matches.iterrows():
+        goalscorers = get_match_goalscorers(match['date'], match['home_team'], match['away_team'])
+        last_n_results.append({
+            "date": match['date'], "home_team": match['home_team'], "away_team": match['away_team'],
+            "home_score": int(match['home_score']), "away_score": int(match['away_score']),
+            "tournament": match['tournament'], "goalscorers": goalscorers
+        })
+    
+    total_wins = team1_wins + team2_wins
+    win_prop_team1 = team1_wins / total_wins if total_wins > 0 else 0
+    win_prop_team2 = team2_wins / total_wins if total_wins > 0 else 0
+    total_goals = team1_goals + team2_goals
+    goal_prop_team1 = team1_goals / total_goals if total_goals > 0 else 0
+    goal_prop_team2 = team2_goals / total_goals if total_goals > 0 else 0
+    goal_diff_value = int(abs(goal_diff))
+    goal_diff_prop_team1 = goal_diff_value / (goal_diff_value + 1) if goal_diff_value > 0 else 0.5
+    goal_diff_prop_team2 = 1 - goal_diff_prop_team1 if goal_diff_value > 0 else 0.5
+
+    fig = go.Figure(data=[
+        go.Bar(name=team1, x=[win_prop_team1, goal_prop_team1, goal_diff_prop_team1], y=['Wins', 'Goals', 'Goal Difference'], orientation='h', marker_color='teal'),
+        go.Bar(name=team2, x=[win_prop_team2, goal_prop_team2, goal_diff_prop_team2], y=['Wins', 'Goals', 'Goal Difference'], orientation='h', marker_color='orange')
+    ])
+    fig.update_layout(barmode='stack', title_text=f'Proportion of {team1} vs {team2}', xaxis_title="Proportion", yaxis_title="Categories", xaxis=dict(range=[0, 1]))
+    
+    return {
+        "total_matches": total_matches, f"{team1}_wins": team1_wins, f"{team2}_wins": team2_wins, "draws": draws,
+        f"{team1}_goals": int(team1_goals), f"{team2}_goals": int(team2_goals), "goal_difference": goal_difference_str,
+        "last_matches": last_n_results, "chart": fig.to_json()
+    }
+
+def get_player_stats(player_name):
+    player_goals = goals_df[goals_df['scorer'] == player_name]
+    if player_goals.empty:
+        raise HTTPException(status_code=404, detail="Player not found")
+    total_goals = len(player_goals[player_goals['own_goal'] == False])
+    player_team = player_goals['team'].mode()[0] if not player_goals['team'].empty else "Unknown"
+    return {"player_name": player_name, "country": player_team, "total_goals": total_goals}
+
+def predict_match_outcome(team1, team2):
+    try:
+        teams_sorted = sorted([team1, team2])
+        team1_encoded = le.transform([teams_sorted[0]])[0] if teams_sorted[0] in le.classes_ else -1
+        team2_encoded = le.transform([teams_sorted[1]])[0] if teams_sorted[1] in le.classes_ else -1
+        
+        if team1_encoded == -1 or team2_encoded == -1:
+            raise ValueError("One or both teams not found in training data")
+        
+        X_pred = [[team1_encoded, team2_encoded]]
+        
+        probs = logistic_model.predict_proba(X_pred)[0]
+        
+        if team1 < team2:
+            outcome_probs = {
+                "team1_win": round(probs[0] * 100, 2),
+                "team2_win": round(probs[2] * 100, 2),
+                "draw": round(probs[1] * 100, 2)
+            }
+        else:
+            outcome_probs = {
+                "team1_win": round(probs[2] * 100, 2),
+                "team2_win": round(probs[0] * 100, 2),
+                "draw": round(probs[1] * 100, 2)
+            }
+        
+        if outcome_probs["team1_win"] > outcome_probs["team2_win"] and outcome_probs["team1_win"] >= outcome_probs["draw"]:
+            goals_pred = {"team1_goals": 2, "team2_goals": 1}
+        elif outcome_probs["team2_win"] > outcome_probs["team1_win"] and outcome_probs["team2_win"] >= outcome_probs["draw"]:
+            goals_pred = {"team1_goals": 1, "team2_goals": 2}
+        else:
+            goals_pred = {"team1_goals": 1, "team2_goals": 1}
+        
+        return {
+            "outcome_probabilities": outcome_probs,
+            "predicted_goals": goals_pred
+        }
+    except Exception as e:
+        logger.error(f"Prediction error for {team1} vs {team2}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")
+
+@app.get("/")
+async def home():
+    return {
+        "message": "Welcome to Football Prediction API",
+        "description": "This API provides football statistics, match predictions, and data visualizations",
+        "available_endpoints": {
+            "/teams": "List all teams",
+            "/players": "List all players",
+            "/country-codes": "Get country codes",
+            "/team/{team_name}": "Get team statistics",
+            "/head-to-head/{team1}/{team2}": "Get head-to-head statistics",
+            "/player/{player_name}": "Get player statistics",
+            "/predict/{team1}/{team2}": "Predict match outcome",
+            "/goal-spatial-heatmap/{team}": "Get goal distribution heatmap"
+        }
+    }
+
+@app.get("/teams")
+async def get_teams():
+    return {"teams": sorted(list(teams))}
+
+@app.get("/players")
+async def get_players():
+    return {"players": players}
+
+@app.get("/country-codes")
+async def get_country_codes():
+    return COUNTRY_CODE_MAP
+
+@app.get("/team/{team_name}")
+async def get_team_statistics(team_name: str, summarize: bool = False):
+    if team_name not in teams:
+        raise HTTPException(status_code=404, detail=f"Team {team_name} not found")
+    try:
+        stats = get_team_stats(team_name)
+    except Exception as e:
+        logger.error(f"Error calculating stats for {team_name}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error calculating stats: {str(e)}")
+    
+    response = {"team": team_name, "statistics": stats}
+    
+    if summarize:
+        basic_stats_text = "\n".join([f"{key}: {value}" for key, value in stats.items() if key != "tournament_performance"])
+        tournament_text = "\nTournament Performance:\n" + "\n".join(
+            [f"{tourn}: Matches: {stats['tournament_performance'][tourn]['matches_played']}, "
+             f"Wins: {stats['tournament_performance'][tourn]['wins']}, "
+             f"Losses: {stats['tournament_performance'][tourn]['losses']}, "
+             f"Draws: {stats['tournament_performance'][tourn]['draws']}, "
+             f"Win%: {stats['tournament_performance'][tourn]['win_percentage']}%"
+             for tourn in stats['tournament_performance']]
+        )
+        full_text = f"{basic_stats_text}\n{tournament_text}"
+        summary = summarize_with_groq(full_text)
+        response["summary"] = summary
+    
+    return response
+
+@app.get("/head-to-head/{team1}/{team2}")
+async def get_head_to_head(team1: str, team2: str, num_matches: int = 5, summarize: bool = False):
+    if team1 not in teams or team2 not in teams:
+        raise HTTPException(status_code=404, detail="One or both teams not found")
+    if num_matches < 0:
+        raise HTTPException(status_code=400, detail="Number of matches must be non-negative")
+    stats = get_head_to_head_stats(team1, team2, num_matches)
+    response = {"team1": team1, "team2": team2, "head_to_head_statistics": stats}
+    if summarize:
+        text = "\n".join([f"{key}: {value}" for key, value in stats.items() if key not in ["last_matches", "chart"]] +
+                         [f"Last Match: {match['date']} - {match['home_team']} {match['home_score']} vs {match['away_score']} {match['away_team']}"
+                          for match in stats["last_matches"]])
+        summary = summarize_with_groq(text)
+        response["summary"] = summary
+    return response
+
+@app.get("/player/{player_name}")
+async def get_player_statistics(player_name: str, summarize: bool = False):
+    stats = get_player_stats(player_name)
+    response = stats
+    if summarize:
+        text = "\n".join([f"{key}: {value}" for key, value in stats.items()])
+        summary = summarize_with_groq(text)
+        response["summary"] = summary
+    return response
+
+@app.get("/predict/{team1}/{team2}")
+async def predict_match(team1: str, team2: str, summarize: bool = False):
+    if team1 not in teams or team2 not in teams:
+        raise HTTPException(status_code=404, detail="One or both teams not found")
+    predictions = predict_match_outcome(team1, team2)
+    response = {"team1": team1, "team2": team2, "predictions": predictions}
+    if summarize:
+        text = (f"Outcome Probabilities: {team1} Win: {predictions['outcome_probabilities']['team1_win']}%, "
+                f"{team2} Win: {predictions['outcome_probabilities']['team2_win']}%, Draw: {predictions['outcome_probabilities']['draw']}%\n"
+                f"Predicted Goals: {team1}: {predictions['predicted_goals']['team1_goals']}, {team2}: {predictions['predicted_goals']['team2_goals']}")
+        summary = summarize_with_groq(text)
+        response["summary"] = summary
+    return response
+
+@app.get("/goal-spatial-heatmap/{team}")
+async def get_goal_spatial_heatmap(team: str, start_year: int = 2000, end_year: int = 2023, summarize: bool = False):
+    if team not in teams:
+        raise HTTPException(status_code=404, detail=f"Team {team} not found")
+    
+    if start_year > end_year:
+        raise HTTPException(status_code=400, detail="start_year must be less than or equal to end_year")
+    
+    try:
+        matches_df['date'] = pd.to_datetime(matches_df['date'])
+        goals_df['date'] = pd.to_datetime(goals_df['date'])
+        
+        team_matches = matches_df[
+            ((matches_df['home_team'] == team) | (matches_df['away_team'] == team)) &
+            (matches_df['date'].dt.year >= start_year) & (matches_df['date'].dt.year <= end_year)
+        ]
+        
+        team_goals = goals_df[
+            (goals_df['team'] == team) &
+            (goals_df['date'].dt.year >= start_year) & (goals_df['date'].dt.year <= end_year)
+        ].dropna(subset=['x_coord', 'y_coord'])
+        
+        if team_goals.empty:
+            raise HTTPException(status_code=404, detail=f"No goal data found for {team} in the specified year range")
+        
+        heatmap_data, xedges, yedges = np.histogram2d(
+            team_goals['x_coord'],
+            team_goals['y_coord'],
+            bins=50,
+            range=[[0, 100], [0, 100]]
+        )
+        
+        heatmap_data = heatmap_data / heatmap_data.max() if heatmap_data.max() > 0 else heatmap_data
+        
+        fig = go.Figure(data=go.Heatmap(
+            z=heatmap_data.T,
+            x=xedges,
+            y=yedges,
+            colorscale='Viridis',
+            colorbar=dict(title='Goal Density'),
+            zmin=0,
+            zmax=1
+        ))
+        
+        fig.add_shape(type="rect", x0=0, y0=0, x1=100, y1=100, line=dict(color="white", width=2))
+        fig.add_shape(type="rect", x0=0, y0=20, x1=16, y1=80, line=dict(color="white", width=2))
+        fig.add_shape(type="rect", x0=84, y0=20, x1=100, y1=80, line=dict(color="white", width=2))
+        fig.add_shape(type="rect", x0=0, y0=40, x1=5, y1=60, line=dict(color="white", width=2))
+        fig.add_shape(type="rect", x0=95, y0=40, x1=100, y1=60, line=dict(color="white", width=2))
+        fig.add_shape(type="circle", x0=45, y0=45, x1=55, y1=55, line=dict(color="white", width=2))
+        fig.add_shape(type="line", x0=50, y0=0, x1=50, y1=100, line=dict(color="white", width=2))
+        
+        fig.update_layout(
+            title=f'Goal Distribution Heatmap for {team} ({start_year}-{end_year})',
+            xaxis_title='X Position (Length of Pitch)',
+            yaxis_title='Y Position (Width of Pitch)',
+            xaxis=dict(range=[0, 100], tickvals=[0, 20, 40, 60, 80, 100], showgrid=False),
+            yaxis=dict(range=[0, 100], tickvals=[0, 20, 40, 60, 80, 100], showgrid=False),
+            template="plotly_dark",
+            width=800,
+            height=500,
+            plot_bgcolor='rgba(0,128,0,0.3)',
+            paper_bgcolor='rgba(0,0,0,0)'
+        )
+        
+        response = {
+            "team": team,
+            "start_year": start_year,
+            "end_year": end_year,
+            "heatmap": fig.to_json(),
+            "total_goals": len(team_goals),
+            "average_goals_per_match": round(len(team_goals) / len(team_matches) if len(team_matches) > 0 else 0, 2)
+        }
+        
+        if summarize:
+            text = (f"Goal Distribution for {team} ({start_year}-{end_year})\n"
+                   f"Total Goals: {len(team_goals)}\n"
+                   f"Average Goals per Match: {response['average_goals_per_match']:.2f}")
+            summary = summarize_with_groq(text)
+            response["summary"] = summary
+            
+        return response
+    
+    except Exception as e:
+        logger.error(f"Error generating spatial heatmap for {team}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error generating heatmap: {str(e)}")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.103.1
+uvicorn==0.23.2
+pandas==2.0.3
+plotly==5.15.0
+joblib==1.3.2
+numpy==1.25.2
+groq==0.9.0
+python-dotenv==1.0.0