deploy backend files

.gitattributes

@@ -0,0 +1,2 @@
+*.csv filter=lfs diff=lfs merge=lfs -text
+data/*.csv filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file first (to leverage Docker caching)
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose the port FastAPI runs on
+EXPOSE 7860
+
+# Command to run FastAPI using Uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,8 @@
+---
+title: Cricket Match Prediction FastAPI
+emoji: 🦀
+colorFrom: pink
+colorTo: purple
+sdk: docker
+pinned: false
+---

data/cleaned_ball_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1263c36a2879b900f4e890d1b497bcdc4b934fd70d8ee4b4c2795a0f454f7da5
+size 190499854

data/cleaned_match_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bf73513be1bf6417b86a25d78308137534724109771eb5aaa15339167476535
+size 384786

data/data_clean.py

@@ -0,0 +1,46 @@
+import pandas as pd
+
+# Load ball-by-ball dataset with low_memory=False to handle mixed types
+ball_df = pd.read_csv('ODI_Match_Data.csv', low_memory=False)
+
+# Clean ball-by-ball dataset
+ball_df['match_id'] = ball_df['match_id'].astype(int)  # Ensure match_id is an integer
+ball_df['season'] = ball_df['season'].astype(str).str.strip()  # Ensure season is a string, handle mixed types
+ball_df['start_date'] = pd.to_datetime(ball_df['start_date'], errors='coerce')  # Convert to datetime, handle invalid dates
+ball_df['runs_off_bat'] = ball_df['runs_off_bat'].fillna(0).astype(int)
+ball_df['extras'] = ball_df['extras'].fillna(0).astype(int)
+ball_df['wides'] = ball_df['wides'].fillna(0).astype(int)
+ball_df['noballs'] = ball_df['noballs'].fillna(0).astype(int)
+ball_df['byes'] = ball_df['byes'].fillna(0).astype(int)
+ball_df['legbyes'] = ball_df['legbyes'].fillna(0).astype(int)
+ball_df['penalty'] = ball_df['penalty'].fillna(0).astype(int)
+ball_df['wicket_type'] = ball_df['wicket_type'].notna().astype(int)  # 1 if wicket, 0 if not
+ball_df['batting_team'] = ball_df['batting_team'].astype(str).str.strip().str.title()  # Ensure string, then title case
+ball_df['bowling_team'] = ball_df['bowling_team'].astype(str).str.strip().str.title()
+ball_df['striker'] = ball_df['striker'].astype(str).str.strip().str.title()
+ball_df['non_striker'] = ball_df['non_striker'].astype(str).str.strip().str.title()
+ball_df['bowler'] = ball_df['bowler'].astype(str).str.strip().str.title()
+ball_df['player_dismissed'] = ball_df['player_dismissed'].astype(str).str.strip().str.title()  # Ensure string, then title case
+
+# Handle 'other_player_dismissed' - check if it's numeric or non-string, convert to string if possible
+if ball_df['other_player_dismissed'].dtype != 'object':  # If not string type
+    ball_df['other_player_dismissed'] = ball_df['other_player_dismissed'].astype(str).str.strip().str.title()
+else:
+    # If already object type, handle NaN or non-string values
+    ball_df['other_player_dismissed'] = ball_df['other_player_dismissed'].fillna('').astype(str).str.strip().str.title()
+
+ball_df['other_wicket_type'] = ball_df['other_wicket_type'].astype(str).str.strip()  # Ensure string, handle as is
+
+# Extract venue if needed (assuming start_date might contain venue or it's separate)
+if 'venue' not in ball_df.columns:
+    if 'start_date' in ball_df.columns and ball_df['start_date'].dtype == 'object':
+        ball_df['venue'] = ball_df['start_date'].str.extract(r', (.+)$').fillna('N/A')
+    else:
+        ball_df['venue'] = 'N/A'  # Default if venue isn’t available
+
+# Calculate total runs (including extras)
+ball_df['total_runs'] = ball_df['runs_off_bat'] + ball_df['extras']
+
+# Save cleaned ball-by-ball dataset
+ball_df.to_csv('cleaned_ball_data.csv', index=False)
+print("Cleaned ball-by-ball dataset saved as 'cleaned_ball_data.csv'")

main.py

@@ -0,0 +1,10 @@
+from fastapi import FastAPI
+from routers import router
+
+app = FastAPI(title="Cricket Statistics API")
+
+app.include_router(router)
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to the Cricket Statistics API"}

models/train_model.py

@@ -0,0 +1,295 @@
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingRegressor
+from sklearn.multioutput import MultiOutputRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, accuracy_score, r2_score
+from sklearn.preprocessing import StandardScaler
+import joblib
+
+# Load datasets with exact column names
+ball_df = pd.read_csv('data/cleaned_ball_data.csv', 
+                      dtype={
+                          'match_id': str, 'season': str, 'start_date': str, 'venue': str,
+                          'innings': int, 'ball': float, 'batting_team': str, 'bowling_team': str,
+                          'striker': str, 'non_striker': str, 'bowler': str, 'runs_off_bat': int,
+                          'extras': int, 'wides': float, 'noballs': float, 'byes': float,
+                          'legbyes': float, 'penalty': float, 'wicket_type': str,
+                          'player_dismissed': str, 'other_wicket_type': str,
+                          'other_player_dismissed': str, 'cricsheet_id': str, 'total_runs': int
+                      })
+match_df = pd.read_csv('data/cleaned_match_data.csv', 
+                       dtype={
+                           'id': str, 'season': str, 'city': str, 'date': str,
+                           'team1': str, 'team2': str, 'toss_winner': str, 'toss_decision': str,
+                           'result': str, 'dl_applied': int, 'winner': str,
+                           'win_by_runs': float, 'win_by_wickets': float, 'player_of_match': str,
+                           'venue': str, 'umpire1': str, 'umpire2': str, 'umpire3': str
+                       })
+
+# Convert date columns to datetime
+match_df['date'] = pd.to_datetime(match_df['date'], errors='coerce')
+ball_df['start_date'] = pd.to_datetime(ball_df['start_date'], errors='coerce')
+
+# Filter for ODI matches (proxy based on date range; adjust as needed)
+odi_date_mask = (match_df['date'].dt.year >= 2015) & (match_df['date'].dt.year <= 2022)
+match_df = match_df[odi_date_mask].copy()
+
+# Compute team total scores from ball_df
+team_scores = ball_df.groupby(['match_id', 'batting_team'])['total_runs'].sum().reset_index()
+team_scores.rename(columns={'total_runs': 'team_total'}, inplace=True)
+
+# Merge computed scores into match_df with better handling for missing data
+match_df = match_df.merge(team_scores, left_on=['id', 'team1'], right_on=['match_id', 'batting_team'], how='left')
+match_df.rename(columns={'team_total': 'team1_total'}, inplace=True)
+match_df['team1_total'] = match_df['team1_total'].fillna(match_df['team1_total'].mean())
+match_df = match_df.merge(team_scores, left_on=['id', 'team2'], right_on=['match_id', 'batting_team'], how='left')
+match_df.rename(columns={'team_total': 'team2_total'}, inplace=True)
+match_df['team2_total'] = match_df['team2_total'].fillna(match_df['team2_total'].mean())
+
+# Drop extra columns created during merging
+match_df.drop(columns=['batting_team', 'match_id'], errors='ignore', inplace=True)
+
+# Add venue and city indices
+match_df['venue_index'] = match_df['venue'].astype('category').cat.codes
+match_df['city_index'] = match_df['city'].astype('category').cat.codes
+
+# Add toss features
+match_df['toss_winner_index'] = match_df['toss_winner'].astype('category').cat.codes
+match_df['toss_decision_index'] = match_df['toss_decision'].map({'bat': 1, 'field': 0}).fillna(0).astype(int)
+
+# Compute historical win rates for each team (weighted by recency)
+match_df['date_numeric'] = (match_df['date'] - pd.Timestamp("1970-01-01")) // pd.Timedelta('1d')
+max_date = match_df['date_numeric'].max()
+team1_wins = match_df[match_df['winner'] == match_df['team1']].groupby('team1').agg({'date_numeric': 'mean', 'id': 'count'}).reset_index()
+team1_wins.rename(columns={'id': 'wins', 'date_numeric': 'win_date', 'team1': 'team'}, inplace=True)
+team2_wins = match_df[match_df['winner'] == match_df['team2']].groupby('team2').agg({'date_numeric': 'mean', 'id': 'count'}).reset_index()
+team2_wins.rename(columns={'id': 'wins', 'date_numeric': 'win_date', 'team2': 'team'}, inplace=True)
+team_wins = pd.concat([team1_wins, team2_wins]).groupby('team').agg({'wins': 'sum', 'win_date': 'mean'}).reset_index()
+team1_matches = match_df.groupby('team1').size().reset_index(name='matches')
+team1_matches.rename(columns={'team1': 'team'}, inplace=True)
+team2_matches = match_df.groupby('team2').size().reset_index(name='matches')
+team2_matches.rename(columns={'team2': 'team'}, inplace=True)
+team_matches = pd.concat([team1_matches, team2_matches]).groupby('team')['matches'].sum().reset_index()
+team_win_rates = team_matches.merge(team_wins, on='team', how='left').fillna(0)
+team_win_rates['weighted_wins'] = team_win_rates.apply(lambda x: x['wins'] * np.exp(-0.1 * (max_date - x['win_date']) / 365) if pd.notna(x['win_date']) else 0, axis=1)
+team_win_rates['win_rate'] = team_win_rates['weighted_wins'] / team_win_rates['matches']
+team_win_rates['win_rate'] = team_win_rates['win_rate'].fillna(0)
+match_df = match_df.merge(team_win_rates[['team', 'win_rate']].rename(columns={'team': 'team1', 'win_rate': 'team1_win_rate'}), on='team1', how='left')
+match_df = match_df.merge(team_win_rates[['team', 'win_rate']].rename(columns={'team': 'team2', 'win_rate': 'team2_win_rate'}), on='team2', how='left')
+
+# Compute head-to-head win rates with minimum match threshold
+head_to_head = match_df[match_df['team1'].isin(match_df['team1'].unique()) & match_df['team2'].isin(match_df['team2'].unique())]
+head_to_head_wins = head_to_head[head_to_head['winner'] == head_to_head['team1']].groupby(['team1', 'team2']).size().reset_index(name='h2h_wins')
+head_to_head_matches = head_to_head.groupby(['team1', 'team2']).size().reset_index(name='h2h_matches')
+h2h_win_rates = head_to_head_matches.merge(head_to_head_wins, on=['team1', 'team2'], how='left').fillna(0)
+h2h_win_rates = h2h_win_rates[head_to_head_matches['h2h_matches'] >= 1]
+h2h_win_rates['h2h_win_rate'] = h2h_win_rates['h2h_wins'] / h2h_win_rates['h2h_matches']
+match_df = match_df.merge(h2h_win_rates[['team1', 'team2', 'h2h_win_rate']], on=['team1', 'team2'], how='left').fillna(0)
+
+# Cap outliers in target variables
+match_df['team1_total'] = match_df['team1_total'].clip(upper=500)
+match_df['team2_total'] = match_df['team2_total'].clip(upper=500)
+
+# Train Team Performance Prediction Model
+def train_team_performance_model():
+    data = match_df[['team1', 'team2', 'winner', 'team1_total', 'team2_total', 'venue_index', 'city_index', 
+                     'toss_winner_index', 'toss_decision_index', 'dl_applied', 'team1_win_rate', 
+                     'team2_win_rate', 'h2h_win_rate']].dropna()
+
+    # Convert categorical teams to numerical indices
+    data['team1_index'] = data['team1'].astype('category').cat.codes
+    data['team2_index'] = data['team2'].astype('category').cat.codes
+    data['winner_index'] = (data['winner'] == data['team1']).astype(int)
+
+    # Features and targets
+    X = pd.DataFrame()
+    X['team1_index'] = data['team1_index']
+    X['team2_index'] = data['team2_index']
+    X['venue_index'] = data['venue_index']
+    X['city_index'] = data['city_index']
+    X['toss_winner_index'] = data['toss_winner_index']
+    X['toss_decision_index'] = data['toss_decision_index']
+    X['dl_applied'] = data['dl_applied']
+    X['team1_win_rate'] = data['team1_win_rate']
+    X['team2_win_rate'] = data['team2_win_rate']
+    X['h2h_win_rate'] = data['h2h_win_rate'] * 2  # Double weight to head-to-head
+
+    y_win = data['winner_index']
+    y_score = data[['team1_total', 'team2_total']]
+
+    # Scale numerical features
+    scaler = StandardScaler()
+    scaled_features = scaler.fit_transform(X[['venue_index', 'city_index', 'toss_winner_index', 'toss_decision_index', 
+                                             'dl_applied', 'team1_win_rate', 'team2_win_rate', 'h2h_win_rate']])
+    X_scaled = pd.DataFrame(scaled_features, columns=['venue_index', 'city_index', 'toss_winner_index', 'toss_decision_index', 
+                                                     'dl_applied', 'team1_win_rate', 'team2_win_rate', 'h2h_win_rate'])
+    X_scaled['team1_index'] = X['team1_index']
+    X_scaled['team2_index'] = X['team2_index']
+
+    # Train/test split for win prediction
+    X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_win, test_size=0.2, random_state=42)
+
+    # Train RandomForestClassifier with tuned hyperparameters
+    win_model = RandomForestClassifier(n_estimators=200, max_depth=15, random_state=42, class_weight='balanced')
+    win_model.fit(X_train, y_train)
+
+    # Evaluate
+    y_pred = win_model.predict(X_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    print(f"Team Win Model Accuracy: {accuracy}")
+
+    # Train HistGradientBoostingRegressor with MultiOutputRegressor for score prediction
+    base_score_model = HistGradientBoostingRegressor(random_state=42, learning_rate=0.1, max_iter=100)
+    score_model = MultiOutputRegressor(base_score_model)
+    score_model.fit(X_scaled, y_score)
+
+    # Evaluate score model
+    y_score_pred = score_model.predict(X_scaled)
+    mse = mean_squared_error(y_score, y_score_pred)
+    r2 = r2_score(y_score, y_score_pred)
+    print(f"Team Score Model MSE: {mse}, R²: {r2}")
+
+    # Save models and scaler
+    joblib.dump((win_model, score_model, data, scaler), 'models/team_performance_predictor.pkl')
+
+# Train Player Score Prediction Model
+def train_player_score_model():
+    # Aggregate player runs per match from ball_df, including batting_team
+    player_runs = ball_df.groupby(['match_id', 'striker', 'batting_team'])['runs_off_bat'].sum().reset_index()
+    player_runs.rename(columns={'runs_off_bat': 'player_total'}, inplace=True)
+
+    # Merge with match_df to get match context
+    player_data = player_runs.merge(match_df, left_on='match_id', right_on='id', how='left')
+
+    # Feature engineering for player performance
+    player_data['player_avg'] = player_data.groupby('striker')['player_total'].transform('mean')  # Average runs per player
+    player_data['team_win_rate'] = player_data.apply(lambda x: player_data[player_data['team1'] == x['batting_team']]['team1_win_rate'].mean() 
+                                                    if x['batting_team'] == x['team1'] else player_data[player_data['team2'] == x['batting_team']]['team2_win_rate'].mean(), axis=1)
+    player_data['venue_index'] = player_data['venue'].astype('category').cat.codes
+    player_data['city_index'] = player_data['city'].astype('category').cat.codes
+    player_data['toss_winner_index'] = player_data['toss_winner'].astype('category').cat.codes
+    player_data['toss_decision_index'] = player_data['toss_decision'].map({'bat': 1, 'field': 0}).fillna(0).astype(int)
+
+    # Features and target
+    X = player_data[['player_avg', 'team_win_rate', 'venue_index', 'city_index', 'toss_winner_index', 'toss_decision_index']].dropna()
+    y = player_data.loc[X.index, 'player_total']
+
+    # Scale numerical features
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+
+    # Train/test split
+    X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
+
+    # Train HistGradientBoostingRegressor
+    score_model = HistGradientBoostingRegressor(random_state=42, learning_rate=0.1, max_iter=100)
+    score_model.fit(X_train, y_train)
+
+    # Evaluate
+    y_pred = score_model.predict(X_test)
+    mse = mean_squared_error(y_test, y_pred)
+    r2 = r2_score(y_test, y_pred)
+    print(f"Player Score Model MSE: {mse}, R²: {r2}")
+
+    # Save model and scaler
+    joblib.dump((score_model, scaler, player_data), 'models/player_score_predictor.pkl')
+
+# Predict Player Score
+def predict_player_score(player: str, team: str, opponent: str, venue: str = None, city: str = None, 
+                        toss_winner: str = None, toss_decision: str = None):
+    try:
+        score_model, scaler, player_data = joblib.load('models/player_score_predictor.pkl')
+
+        if player not in player_data['striker'].values or team not in player_data['batting_team'].values:
+            raise ValueError("Player or team not found in training data")
+
+        # Compute player average from historical data
+        player_avg = player_data[player_data['striker'] == player]['player_total'].mean()
+        team_win_rate = player_data[player_data['batting_team'] == team]['team_win_rate'].mean()
+
+        # Use specific values if provided, otherwise default to mean
+        venue_index = player_data[player_data['venue'] == venue]['venue_index'].values[0] if venue else player_data['venue_index'].mean()
+        city_index = player_data[player_data['city'] == city]['city_index'].values[0] if city else player_data['city_index'].mean()
+        toss_winner_index = player_data[player_data['toss_winner'] == toss_winner]['toss_winner_index'].values[0] if toss_winner else player_data['toss_winner_index'].mean()
+        toss_decision_index = 1 if toss_decision == 'bat' else 0 if toss_decision == 'field' else player_data['toss_decision_index'].mean()
+
+        # Scale features
+        features = scaler.transform([[player_avg, team_win_rate, venue_index, city_index, toss_winner_index, toss_decision_index]])
+        predicted_score = score_model.predict(features)[0]
+
+        return {
+            "player": player,
+            "team": team,
+            "opponent": opponent,
+            "expected_score": round(predicted_score, 2)
+        }
+    except Exception as e:
+        print(f"Prediction error: {str(e)}")
+        return {
+            "player": player,
+            "team": team,
+            "opponent": opponent,
+            "expected_score": 0.0
+        }
+
+# Predict Team Win Percentage & Expected Score with debugging
+def predict_team_performance(team1: str, team2: str, venue: str = None, city: str = None, 
+                            toss_winner: str = None, toss_decision: str = None):
+    try:
+        win_model, score_model, data, scaler = joblib.load('models/team_performance_predictor.pkl')
+
+        if team1 not in data['team1'].values or team2 not in data['team2'].values:
+            raise ValueError("Team not found in training data")
+
+        # Get team indices
+        team1_index = data[data['team1'] == team1]['team1_index'].values[0]
+        team2_index = data[data['team2'] == team2]['team2_index'].values[0]
+
+        # Use specific values if provided, otherwise default to mean
+        venue_index = data[data['venue'] == venue]['venue_index'].values[0] if venue else data['venue_index'].mean()
+        city_index = data[data['city'] == city]['city_index'].values[0] if city else data['city_index'].mean()
+        toss_winner_index = data[data['toss_winner'] == toss_winner]['toss_winner_index'].values[0] if toss_winner else data['toss_winner_index'].mean()
+        toss_decision_index = 1 if toss_decision == 'bat' else 0 if toss_decision == 'field' else data['toss_decision_index'].mean()
+        dl_applied = 0 if pd.isna(toss_decision) else data['dl_applied'].mean()
+        team1_win_rate = data[data['team1'] == team1]['team1_win_rate'].values[0]
+        team2_win_rate = data[data['team2'] == team2]['team2_win_rate'].values[0]
+        h2h_win_rate = data[(data['team1'] == team1) & (data['team2'] == team2)]['h2h_win_rate'].values[0] if not data[(data['team1'] == team1) & (data['team2'] == team2)].empty else 0
+
+        # Debug head-to-head and win rates
+        print(f"Team1: {team1}, Team2: {team2}, h2h_win_rate: {h2h_win_rate}, team1_win_rate: {team1_win_rate}, team2_win_rate: {team2_win_rate}")
+
+        # Scale features
+        features = scaler.transform([[venue_index, city_index, toss_winner_index, toss_decision_index, dl_applied, 
+                                     team1_win_rate, team2_win_rate, h2h_win_rate]])
+        win_probability = win_model.predict_proba([[team1_index, team2_index, features[0][0], features[0][1], 
+                                                   features[0][2], features[0][3], features[0][4], features[0][5], 
+                                                   features[0][6], features[0][7]]])[:, 1][0] * 100
+        predicted_scores = score_model.predict([[team1_index, team2_index, features[0][0], features[0][1], 
+                                                features[0][2], features[0][3], features[0][4], features[0][5], 
+                                                features[0][6], features[0][7]]])[0]
+
+        if np.isnan(predicted_scores[0]) or np.isnan(predicted_scores[1]):
+            print(f"Warning: Predicted scores are NaN for {team1} vs {team2}")
+
+        return {
+            "team1": team1,
+            "team2": team2,
+            "win_probability_team1": round(win_probability, 2),
+            "expected_team1_score": round(predicted_scores[0], 2),
+            "expected_team2_score": round(predicted_scores[1], 2)
+        }
+    except Exception as e:
+        print(f"Prediction error: {str(e)}")
+        return {
+            "team1": team1,
+            "team2": team2,
+            "win_probability_team1": 50.0,
+            "expected_team1_score": 0.0,
+            "expected_team2_score": 0.0
+        }
+
+# Train the models
+if __name__ == "__main__":
+    train_team_performance_model()
+    train_player_score_model()

requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+uvicorn
+pandas
+numpy
+groq

routers.py

@@ -0,0 +1,64 @@
+from fastapi import APIRouter, HTTPException
+from services import (
+    get_player_stats,
+    get_team_stats,
+    get_match_history,
+    get_teams,
+    get_players,
+    get_seasons,
+    predict_score,
+    predict_team_outcome,
+    get_team_trends,  # New function for team trends
+    get_player_trends,  # New function for player trends
+)
+
+router = APIRouter()
+
+@router.get("/player-stats/")
+async def player_statistics(player_name: str, season: str = None, role: str = "Batting"):
+    # Validate role parameter
+    if role not in ["Batting", "Bowling"]:
+        raise HTTPException(status_code=400, detail="Role must be 'Batting' or 'Bowling'")
+    return get_player_stats(player_name, season, role)
+
+@router.get("/team-stats/")
+async def team_statistics(team_name: str, season: str = None):
+    return get_team_stats(team_name, season)
+
+@router.get("/match-history/")
+async def match_history(team1: str, team2: str, season: str = None):
+    # Update get_match_history to handle two teams
+    return get_match_history(team1, team2, season)
+
+@router.get("/teams")
+async def teams():
+    return get_teams()
+
+@router.get("/players")
+async def players():
+    return get_players()
+
+@router.get("/seasons")
+async def seasons():
+    return get_seasons()
+
+@router.get("/predict-score/")
+async def predict_player_score_endpoint(player_name: str, opposition_team: str):
+    return predict_score(player_name, opposition_team)
+
+@router.get("/predict-team-outcome/")
+async def predict_team_outcome_endpoint(team1: str, team2: str):
+    return predict_team_outcome(team1, team2)
+
+# New endpoint for team trends over time
+@router.get("/team-trends/")
+async def team_trends(team_name: str):
+    return get_team_trends(team_name)
+
+# New endpoint for player trends over time
+@router.get("/player-trends/")
+async def player_trends(player_name: str, role: str = "Batting"):
+    # Validate role parameter
+    if role not in ["Batting", "Bowling"]:
+        raise HTTPException(status_code=400, detail="Role must be 'Batting' or 'Bowling'")
+    return get_player_trends(player_name, role)

services.py

@@ -0,0 +1,292 @@
+import pandas as pd
+import numpy as np
+from fastapi import HTTPException
+from models.train_model import predict_player_score, predict_team_performance
+from groq import Groq
+
+# Initialize Groq client with your API key
+GROQ_API_KEY = "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"
+client = Groq(api_key=GROQ_API_KEY)
+
+# Load datasets
+match_df = pd.read_csv('data/cleaned_match_data.csv')
+match_df['date'] = pd.to_datetime(match_df['date'], errors='coerce')
+ball_df = pd.read_csv('data/cleaned_ball_data.csv', low_memory=False)
+
+# Create a player-team mapping based on ball_df
+player_team_mapping = ball_df.groupby('striker')['batting_team'].agg(lambda x: x.mode()[0] if len(x.mode()) > 0 else None).to_dict()
+
+# Function to clean JSON data
+def clean_json(data):
+    if isinstance(data, dict):
+        return {k: clean_json(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [clean_json(v) for v in data]
+    elif isinstance(data, float):
+        return 0.0 if pd.isna(data) or np.isinf(data) else data
+    elif pd.isna(data):
+        return None
+    elif isinstance(data, pd.Timestamp):
+        return data.strftime('%Y-%m-%d') if pd.notna(data) else None
+    elif isinstance(data, (int, bool)):
+        return data
+    return str(data)
+
+# LLM summary generation function using Groq
+def generate_summary(data, context_type):
+    prompt = ""
+    if context_type == "player_stats":
+        prompt = f"Summarize this player data in one sentence: {data}"
+    elif context_type == "team_stats":
+        prompt = f"Summarize this team data in one sentence: {data}"
+    elif context_type == "match_history":
+        prompt = f"Summarize this match history between {data['team1']} and {data['team2']} in one sentence: {data['matches']}"
+    elif context_type == "prediction_score":
+        prompt = f"Summarize this prediction in one sentence: {data}"
+    elif context_type == "prediction_team":
+        prompt = f"Summarize this team prediction in one sentence: {data}"
+
+    try:
+        chat_completion = client.chat.completions.create(
+            model="mixtral-8x7b-32768",
+            messages=[
+                {"role": "system", "content": "You are a concise cricket analyst."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=50,
+            temperature=0.7
+        )
+        summary = chat_completion.choices[0].message.content.strip()
+        return summary
+    except Exception as e:
+        return f"Summary unavailable due to error: {str(e)}"
+
+# Player statistics with name variation handling
+def get_player_stats(player_name: str, season: str = None, role: str = "Batting"):
+    player_name = player_name.strip().title()
+    name_variations = [player_name, player_name.replace(" ", ""), " ".join(reversed(player_name.split()))]
+    player_data = ball_df[ball_df['striker'].isin(name_variations) | ball_df['bowler'].isin(name_variations)]
+    if season and 'season' in ball_df.columns:
+        player_data = player_data[player_data['season'] == season]
+    if player_data.empty:
+        raise HTTPException(status_code=404, detail=f"Player '{player_name}' not found. Variations tried: {name_variations}")
+
+    if role == "Batting":
+        batting_data = player_data[player_data['striker'].isin(name_variations)]
+        total_runs = int(batting_data['runs_off_bat'].sum())
+        balls_faced = int(batting_data.shape[0])
+        strike_rate = float((total_runs / balls_faced * 100) if balls_faced > 0 else 0)
+        matches_played = int(len(batting_data['match_id'].unique()))
+
+        stats = {
+            "player_name": player_name,
+            "role": role,
+            "total_runs": total_runs,
+            "balls_faced": balls_faced,
+            "strike_rate": strike_rate,
+            "matches_played": matches_played,
+            "season": season if season else "All Seasons"
+        }
+        stats["summary"] = generate_summary(stats, "player_stats")
+        return clean_json(stats)
+
+    elif role == "Bowling":
+        bowling_data = player_data[player_data['bowler'].isin(name_variations)]
+        bowler_wicket_types = ["caught", "bowled", "lbw", "caught and bowled", "hit wicket"]
+        wickets_data = bowling_data[bowling_data['player_dismissed'].notna() & 
+                                   bowling_data['wicket_type'].isin(bowler_wicket_types)]
+        total_wickets = int(wickets_data.shape[0])
+        total_runs_conceded = int(bowling_data['total_runs'].sum())
+        total_balls_bowled = int(bowling_data.shape[0])
+        total_overs_bowled = float(total_balls_bowled / 6)
+        bowling_average = float(total_runs_conceded / total_wickets) if total_wickets > 0 else float('inf')
+        economy_rate = float(total_runs_conceded / total_overs_bowled) if total_overs_bowled > 0 else 0
+        bowling_strike_rate = float(total_balls_bowled / total_wickets) if total_wickets > 0 else float('inf')
+        bowling_matches = int(len(bowling_data['match_id'].unique()))
+
+        stats = {
+            "player_name": player_name,
+            "role": role,
+            "total_wickets": total_wickets,
+            "bowling_average": 0.0 if np.isinf(bowling_average) else round(bowling_average, 2),
+            "economy_rate": round(economy_rate, 2),
+            "bowling_strike_rate": 0.0 if np.isinf(bowling_strike_rate) else round(bowling_strike_rate, 2),
+            "overs_bowled": round(total_overs_bowled, 1),
+            "bowling_matches": bowling_matches,
+            "season": season if season else "All Seasons"
+        }
+        stats["summary"] = generate_summary(stats, "player_stats")
+        return clean_json(stats)
+
+# Team statistics
+def get_team_stats(team_name: str, season: str = None):
+    team_name = team_name.strip().title()
+    team_matches = match_df[(match_df['team1'] == team_name) | (match_df['team2'] == team_name)]
+    if season and 'season' in match_df.columns:
+        team_matches = team_matches[team_matches['season'] == season]
+    if team_matches.empty:
+        raise HTTPException(status_code=404, detail="Team not found")
+
+    wins = int(team_matches[team_matches['winner'] == team_name].shape[0])
+    total_matches = int(team_matches.shape[0])
+
+    stats = {
+        "total_matches": total_matches,
+        "wins": wins,
+        "losses": total_matches - wins,
+        "win_percentage": float((wins / total_matches * 100) if total_matches > 0 else 0),
+        "season": season if season else "All Seasons"
+    }
+    stats["summary"] = generate_summary(stats, "team_stats")
+    return clean_json(stats)
+
+# Match History Retrieval
+def get_match_history(team1: str, team2: str, season: str = None):
+    team1 = team1.strip().title()
+    team2 = team2.strip().title()
+    available_teams = set(match_df['team1'].unique().tolist() + match_df['team2'].unique().tolist())
+    if team1 not in available_teams or team2 not in available_teams:
+        raise HTTPException(status_code=404, detail=f"Team {team1 if team1 not in available_teams else team2} not found.")
+
+    team_matches = match_df[
+        ((match_df['team1'] == team1) & (match_df['team2'] == team2)) |
+        ((match_df['team1'] == team2) & (match_df['team2'] == team1))
+    ].copy()
+    if season and 'season' in match_df.columns:
+        team_matches = team_matches[team_matches['season'] == season]
+    if team_matches.empty:
+        raise HTTPException(status_code=404, detail=f"No match history found between {team1} and {team2}.")
+    
+    team_matches['date'] = team_matches['date'].apply(lambda x: x.strftime('%Y-%m-%d') if pd.notna(x) else None)
+    team_matches['winner'] = team_matches['winner'].fillna("Draw")
+    for column in ['team1', 'team2', 'winner']:
+        team_matches[column] = team_matches[column].apply(lambda x: str(x) if pd.notna(x) else None)
+    history = team_matches[['date', 'team1', 'team2', 'winner']].to_dict(orient='records')
+
+    response = {
+        "team1": team1,
+        "team2": team2,
+        "season": season if season else "All Seasons",
+        "matches": history
+    }
+    response["summary"] = generate_summary(response, "match_history")
+    return clean_json(response)
+
+# Prediction functions
+def predict_score(player_name: str, opposition_team: str):
+    try:
+        # Handle name variations
+        player_name = player_name.strip().replace("+", " ").title()
+        name_variations = [player_name, player_name.replace(" ", ""), " ".join(reversed(player_name.split()))]
+        player_team = None
+        for name in name_variations:
+            if name in player_team_mapping:
+                player_team = player_team_mapping[name]
+                player_name = name  # Use the matched name
+                break
+        if not player_team:
+            raise ValueError(f"Player {player_name} not found in historical data")
+
+        # Debug: Print arguments before calling predict_player_score
+        print(f"Calling predict_player_score with: player={player_name}, team={player_team}, opponent={opposition_team}")
+
+        predicted_runs = predict_player_score(
+            player=player_name,
+            team=player_team,
+            opponent=opposition_team,
+            venue=None,
+            city=None,
+            toss_winner=None,
+            toss_decision=None
+        )
+        stats = {
+            "player": player_name,
+            "team": player_team,
+            "opposition": opposition_team,
+            "predicted_runs": predicted_runs["expected_score"]
+        }
+        stats["summary"] = generate_summary(stats, "prediction_score")
+        return clean_json(stats)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error predicting score for {player_name} against {opposition_team}: {str(e)}")
+
+def predict_team_outcome(team1: str, team2: str):
+    prediction = predict_team_performance(team1, team2)
+    prediction["summary"] = generate_summary(prediction, "prediction_team")
+    return clean_json(prediction)
+
+# Utility functions
+def get_teams():
+    return clean_json({"teams": sorted(set(match_df['team1'].unique().tolist() + match_df['team2'].unique().tolist()))})
+
+def get_players():
+    unique_players = sorted(set(ball_df['striker'].dropna().unique().tolist()))
+    return clean_json({"players": unique_players})
+
+def get_seasons():
+    return clean_json({"seasons": ["All Seasons"] + sorted(match_df['season'].dropna().unique().tolist())})
+
+# New function for team trends over time
+def get_team_trends(team_name: str):
+    team_name = team_name.strip().title()
+    team_matches = match_df[(match_df['team1'] == team_name) | (match_df['team2'] == team_name)]
+    if team_matches.empty:
+        raise HTTPException(status_code=404, detail="Team not found")
+
+    # Calculate win percentage and other metrics for each season
+    trends = []
+    for season in match_df['season'].unique():
+        season_matches = team_matches[team_matches['season'] == season]
+        if not season_matches.empty:
+            wins = season_matches[season_matches['winner'] == team_name].shape[0]
+            total_matches = season_matches.shape[0]
+            win_percentage = (wins / total_matches * 100) if total_matches > 0 else 0
+            trends.append({
+                "season": season,
+                "wins": wins,
+                "total_matches": total_matches,
+                "win_percentage": win_percentage
+            })
+
+    return {"team_name": team_name, "trends": trends}
+
+# New function for player trends over time
+def get_player_trends(player_name: str, role: str = "Batting"):
+    player_name = player_name.strip().title()
+    name_variations = [player_name, player_name.replace(" ", ""), " ".join(reversed(player_name.split()))]
+    player_data = ball_df[ball_df['striker'].isin(name_variations) | ball_df['bowler'].isin(name_variations)]
+    if player_data.empty:
+        raise HTTPException(status_code=404, detail=f"Player '{player_name}' not found")
+
+    # Calculate performance metrics for each season
+    trends = []
+    for season in ball_df['season'].unique():
+        season_data = player_data[player_data['season'] == season]
+        if not season_data.empty:
+            if role == "Batting":
+                total_runs = int(season_data['runs_off_bat'].sum())
+                balls_faced = int(season_data.shape[0])
+                strike_rate = float((total_runs / balls_faced * 100) if balls_faced > 0 else 0)
+                matches_played = int(len(season_data['match_id'].unique()))
+                trends.append({
+                    "season": season,
+                    "total_runs": total_runs,
+                    "strike_rate": strike_rate,
+                    "matches_played": matches_played
+                })
+            elif role == "Bowling":
+                total_wickets = int(season_data[season_data['wicket_type'].notna()].shape[0])
+                total_runs_conceded = int(season_data['total_runs'].sum())
+                total_overs_bowled = float(season_data.shape[0] / 6)
+                bowling_average = float(total_runs_conceded / total_wickets) if total_wickets > 0 else float('inf')
+                economy_rate = float(total_runs_conceded / total_overs_bowled) if total_overs_bowled > 0 else 0
+                matches_played = int(len(season_data['match_id'].unique()))
+                trends.append({
+                    "season": season,
+                    "total_wickets": total_wickets,
+                    "bowling_average": bowling_average,
+                    "economy_rate": economy_rate,
+                    "matches_played": matches_played
+                })
+
+    return {"player_name": player_name, "role": role, "trends": trends}