backend commit

app/main.py

@@ -10,18 +10,15 @@ import json
 from groq import Groq
 from dotenv import load_dotenv
 
-# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Load environment variables
 load_dotenv()
 GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 if not GROQ_API_KEY:
     logger.error("GROQ_API_KEY not found in environment variables.")
     raise Exception("GROQ_API_KEY not found in environment variables.")
 
-# Log and clear proxy environment variables
 logger.info(f"HTTP_PROXY: {os.environ.get('HTTP_PROXY')}")
 logger.info(f"HTTPS_PROXY: {os.environ.get('HTTPS_PROXY')}")
 os.environ.pop("HTTP_PROXY", None)
@@ -29,7 +26,6 @@ os.environ.pop("HTTPS_PROXY", None)
 os.environ.pop("NO_PROXY", None)
 logger.info("Proxy environment variables cleared to prevent 'proxies' error.")
 
-# Initialize Groq client
 try:
     client = Groq(api_key=GROQ_API_KEY)
     logger.info("Groq client initialized successfully.")
@@ -39,7 +35,6 @@ except Exception as e:
 
 app = FastAPI()
 
-# Enable CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -48,7 +43,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Load datasets and country codes
 try:
     matches_df = pd.read_csv('data/results.csv')
     goals_df = pd.read_csv('data/goalscorers.csv')
@@ -75,10 +69,17 @@ 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)])
 
-# Skip model loading for now
 logger.warning("Model loading skipped due to compatibility issues. Prediction endpoint disabled.")
 
 def summarize_with_groq(text):
+    """Generate a concise summary of the provided text using the Groq API.
+
+    Args:
+        text (str): The text to summarize.
+
+    Returns:
+        str: A summary of the text or an error message if summarization fails.
+    """
     try:
         chat_completion = client.chat.completions.create(
             messages=[
@@ -94,6 +95,15 @@ def summarize_with_groq(text):
         return "Summary unavailable due to an error."
 
 def get_team_stats(team_name):
+    """Calculate comprehensive statistics for a specified football team.
+
+    Args:
+        team_name (str): The name of the team to analyze.
+
+    Returns:
+        dict: A dictionary containing team statistics including total matches, wins, losses, draws,
+              home/away matches played, tournament performance, and country code.
+    """
     home_matches = matches_df[matches_df['home_team'] == team_name]
     away_matches = matches_df[matches_df['away_team'] == team_name]
     
@@ -113,7 +123,7 @@ def get_team_stats(team_name):
     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'] < home_matches['home_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']])
     
@@ -152,18 +162,38 @@ def get_team_stats(team_name):
     }
 
 def get_match_goalscorers(date, home_team, away_team):
+    """Retrieve goalscorers for a specific match.
+
+    Args:
+        date (str): The date of the match.
+        home_team (str): The home team name.
+        away_team (str): The away team name.
+
+    Returns:
+        list: A list of dictionaries containing goalscorer details for the match.
+    """
     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):
+    """Calculate head-to-head statistics between two teams.
+
+    Args:
+        team1 (str): The first team name.
+        team2 (str): The second team name.
+        num_matches (int, optional): Number of recent matches to include. Defaults to 5.
+
+    Returns:
+        dict: A dictionary containing head-to-head stats including wins, goals, last matches, and a chart.
+    """
     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}_wins": 0, "goal_difference": "Even",
+                f"{team1}_goals": 0, f"{team2}_goals": 0, "goal_difference": "Even",
                 "last_matches": [], "chart": None}
     
     total_matches = len(matches)
@@ -214,6 +244,17 @@ def get_head_to_head_stats(team1, team2, num_matches=5):
     }
 
 def get_player_stats(player_name):
+    """Retrieve statistics for a specific player.
+
+    Args:
+        player_name (str): The name of the player.
+
+    Returns:
+        dict: A dictionary containing the player's name, country, and total goals.
+
+    Raises:
+        HTTPException: If the player is not found in the dataset.
+    """
     player_goals = goals_df[goals_df['scorer'] == player_name]
     if player_goals.empty:
         raise HTTPException(status_code=404, detail="Player not found")
@@ -222,10 +263,24 @@ def get_player_stats(player_name):
     return {"player_name": player_name, "country": player_team, "total_goals": total_goals}
 
 def predict_match_outcome(team1, team2):
+    """Predict the outcome of a match between two teams.
+
+    Args:
+        team1 (str): The first team name.
+        team2 (str): The second team name.
+
+    Raises:
+        HTTPException: Always raises an exception as prediction is currently disabled.
+    """
     raise HTTPException(status_code=503, detail="Prediction functionality is temporarily disabled due to model loading issues.")
 
 @app.get("/")
 async def home():
+    """Return a welcome message and API description.
+
+    Returns:
+        dict: A dictionary containing welcome message, description, and available endpoints.
+    """
     return {
         "message": "Welcome to Football Prediction API",
         "description": "This API provides football statistics, match predictions, and data visualizations. Note: Prediction endpoint is currently disabled.",
@@ -243,18 +298,45 @@ async def home():
 
 @app.get("/teams")
 async def get_teams():
+    """Retrieve a list of all unique teams.
+
+    Returns:
+        dict: A dictionary containing a sorted list of team names.
+    """
     return {"teams": sorted(list(teams))}
 
 @app.get("/players")
 async def get_players():
+    """Retrieve a list of all unique players.
+
+    Returns:
+        dict: A dictionary containing a sorted list of player names.
+    """
     return {"players": players}
 
 @app.get("/country-codes")
 async def get_country_codes():
+    """Retrieve the country code mapping.
+
+    Returns:
+        dict: A dictionary mapping team names to their country codes.
+    """
     return COUNTRY_CODE_MAP
 
 @app.get("/team/{team_name}")
 async def get_team_statistics(team_name: str, summarize: bool = False):
+    """Get detailed statistics for a specified team.
+
+    Args:
+        team_name (str): The name of the team.
+        summarize (bool, optional): Whether to include a summary. Defaults to False.
+
+    Returns:
+        dict: A dictionary containing team statistics and optionally a summary.
+
+    Raises:
+        HTTPException: If the team is not found or stats calculation fails.
+    """
     if team_name not in teams:
         raise HTTPException(status_code=404, detail=f"Team {team_name} not found")
     try:
@@ -283,6 +365,20 @@ async def get_team_statistics(team_name: str, summarize: bool = False):
 
 @app.get("/head-to-head/{team1}/{team2}")
 async def get_head_to_head(team1: str, team2: str, num_matches: int = 5, summarize: bool = False):
+    """Get head-to-head statistics between two teams.
+
+    Args:
+        team1 (str): The first team name.
+        team2 (str): The second team name.
+        num_matches (int, optional): Number of recent matches to include. Defaults to 5.
+        summarize (bool, optional): Whether to include a summary. Defaults to False.
+
+    Returns:
+        dict: A dictionary containing head-to-head statistics and optionally a summary.
+
+    Raises:
+        HTTPException: If teams are not found or num_matches is negative.
+    """
     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:
@@ -299,6 +395,15 @@ async def get_head_to_head(team1: str, team2: str, num_matches: int = 5, summari
 
 @app.get("/player/{player_name}")
 async def get_player_statistics(player_name: str, summarize: bool = False):
+    """Get statistics for a specified player.
+
+    Args:
+        player_name (str): The name of the player.
+        summarize (bool, optional): Whether to include a summary. Defaults to False.
+
+    Returns:
+        dict: A dictionary containing player statistics and optionally a summary.
+    """
     stats = get_player_stats(player_name)
     response = stats
     if summarize:
@@ -309,10 +414,34 @@ async def get_player_statistics(player_name: str, summarize: bool = False):
 
 @app.get("/predict/{team1}/{team2}")
 async def predict_match(team1: str, team2: str, summarize: bool = False):
+    """Predict the outcome of a match between two teams (currently disabled).
+
+    Args:
+        team1 (str): The first team name.
+        team2 (str): The second team name.
+        summarize (bool, optional): Whether to include a summary. Defaults to False.
+
+    Raises:
+        HTTPException: Always raises an exception as prediction is disabled.
+    """
     raise HTTPException(status_code=503, detail="Prediction functionality is temporarily disabled due to model loading issues.")
 
 @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):
+    """Generate a spatial heatmap of goal distribution for a team.
+
+    Args:
+        team (str): The team name.
+        start_year (int, optional): The starting year for analysis. Defaults to 2000.
+        end_year (int, optional): The ending year for analysis. Defaults to 2023.
+        summarize (bool, optional): Whether to include a summary. Defaults to False.
+
+    Returns:
+        dict: A dictionary containing the heatmap, total goals, and average goals per match.
+
+    Raises:
+        HTTPException: If team not found, years invalid, or no goal data exists.
+    """
     if team not in teams:
         raise HTTPException(status_code=404, detail=f"Team {team} not found")