Update main.py

main.py

@@ -530,7 +530,6 @@ def normalize_string(s):
     """Removes accent marks and converts to lowercase for consistent comparison."""
     if not isinstance(s, str):
         return str(s)
-    # Normalize to NFD (Canonical Decomposition) and remove combining characters
     s = unicodedata.normalize('NFKD', s).encode('ascii', 'ignore').decode('utf-8')
     return s.strip()
 
@@ -659,7 +658,8 @@ def get_player_index_brscraper():
         return df
 
 def _scrape_player_index_brscraper():
-    seasons_to_try_for_index = get_available_seasons_util(num_seasons=3)
+    # Prioritize getting real player data from recent seasons
+    seasons_to_try_for_index = get_available_seasons_util(num_seasons=2) # Try current and previous season
     
     for season_str in seasons_to_try_for_index:
         end_year = int(season_str.split('–')[1])
@@ -669,6 +669,7 @@ def _scrape_player_index_brscraper():
             
             if not df.empty and 'Player' in df.columns:
                 player_names = df['Player'].dropna().unique().tolist()
+                # Normalize player names before returning
                 player_names = [normalize_string(name) for name in player_names]
                 logging.info(f"Successfully retrieved {len(player_names)} players for index from {season_str}.")
                 return pd.DataFrame({'name': player_names})
@@ -677,49 +678,35 @@ def _scrape_player_index_brscraper():
         except Exception as e:
             logging.warning(f"Error fetching player index with BRScraper for {season_str}: {e}. Trying next season.")
 
+    # Fallback to a curated list if recent seasons fail
     logging.error("Failed to fetch player index from recent seasons. Falling back to curated common players list.")
     common_players = [
         'LeBron James', 'Stephen Curry', 'Kevin Durant', 'Giannis Antetokounmpo',
-        'Nikola Jokic',
-        'Joel Embiid', 'Jayson Tatum', 'Luka Doncic',
+        'Nikola Jokic', # No accent here, as it will be normalized
+        'Joel Embiid', 'Jayson Tatum', 'Luka Doncic', # No accent here, as it will be normalized
         'Damian Lillard', 'Jimmy Butler', 'Kawhi Leonard', 'Paul George',
         'Anthony Davis', 'Rudy Gobert', 'Donovan Mitchell', 'Trae Young',
         'Devin Booker', 'Karl-Anthony Towns', 'Zion Williamson', 'Ja Morant',
         'Shai Gilgeous-Alexander', 'Tyrese Maxey', 'Anthony Edwards', 'Victor Wembanyama',
-        'Jalen Brunson', 'Paolo Banchero', 'Franz Wagner', 'Cade Cunningham',
-        'Michael Jordan', 'Kobe Bryant', 'Larry Bird', 'Magic Johnson', 'Kareem Abdul-Jabbar'
+        'Jalen Brunson', 'Paolo Banchero', 'Franz Wagner', 'Cade Cunningham'
     ]
     return pd.DataFrame({'name': common_players})
 
-def get_player_career_stats_brscraper(player_name, seasons_to_fetch: list[str], playoffs=False):
+def get_player_career_stats_brscraper(player_name, seasons_to_check=10, playoffs=False):
     if not BRSCRAPER_AVAILABLE:
         logging.error("BRScraper is not available. Cannot fetch player career stats.")
         return pd.DataFrame()
+    all_rows = []
     
+    # Normalize the input player name for consistent lookup
     normalized_player_name = normalize_string(player_name)
-    all_rows = []
 
-    for season_str in seasons_to_fetch: # Iterate only through the requested seasons
+    seasons_to_try = get_available_seasons_util(seasons_to_check)
+    
+    for season_str in seasons_to_try:
         end_year = int(season_str.split('–')[1])
         
-        # Define cache key for this specific player-season-playoff combination
-        cache_key = f"{normalized_player_name}_{end_year}_{'playoffs' if playoffs else 'regular'}"
-        db_ref = db.reference(f'scraped_data/player_season_stats/{cache_key}')
-
-        # Check Firebase cache first for this specific season
-        if FIREBASE_INITIALIZED:
-            cached_data = db_ref.get()
-            if cached_data and not is_data_stale(cached_data.get('last_updated'), max_age_hours=24*7): # Cache for 7 days
-                logging.info(f"Loading stats for {player_name} in {season_str} (playoffs: {playoffs}) from Firebase cache.")
-                # Return a DataFrame with a single row for this season
-                # Note: This function is designed to return a concatenated DF of ALL requested seasons.
-                # So, if a single season is found in cache, we append it and continue to check others.
-                all_rows.append(pd.DataFrame.from_records(cached_data['data']))
-                continue # Skip scraping for this season if found in cache
-            else:
-                logging.info(f"Stats for {player_name} in {season_str} cache stale or not found. Scraping...")
-
-        # If not in cache or stale, attempt to scrape
+        # Implement retry logic for each season fetch
         for attempt in range(3): # Try up to 3 times
             try:
                 logging.info(f"DEBUG: Attempt {attempt+1} for nba.get_stats for player '{player_name}' in season {season_str} (year: {end_year}, playoffs: {playoffs})...")
@@ -729,50 +716,40 @@ def get_player_career_stats_brscraper(player_name, seasons_to_fetch: list[str],
                 if df_season.empty:
                     logging.warning(f"DEBUG: nba.get_stats returned empty DataFrame for {player_name} in {season_str} on attempt {attempt+1}. Retrying...")
                     time.sleep(1) # Wait a bit before retrying
-                    continue 
+                    continue # Go to next attempt
                 
                 if 'Player' not in df_season.columns:
                     logging.warning(f"DEBUG: DataFrame for {player_name} in {season_str} has no 'Player' column on attempt {attempt+1}. Columns: {df_season.columns.tolist()}. Retrying...")
                     time.sleep(1)
                     continue
 
+                # Normalize player names in the DataFrame for comparison
                 df_season['Player_Normalized'] = df_season['Player'].apply(normalize_string)
+                
                 row = df_season[df_season['Player_Normalized'] == normalized_player_name]
                 
                 if not row.empty:
                     row = row.copy()
                     row['Season'] = season_str
-                    row = row.drop(columns=['Player_Normalized'], errors='ignore') # Remove temp column
-                    
-                    # Save this specific season's data to Firebase cache
-                    if FIREBASE_INITIALIZED:
-                        df_cleaned_for_firebase = clean_df_for_firebase(row.copy())
-                        db_ref.set({
-                            'last_updated': datetime.utcnow().isoformat(),
-                            'data': df_cleaned_for_firebase.to_dict(orient='records')
-                        })
-                        logging.info(f"Stats for {player_name} in {season_str} saved to Firebase cache.")
-                    
-                    all_rows.append(row) # Add to results for current request
+                    # Remove the temporary normalized column before appending
+                    row = row.drop(columns=['Player_Normalized'], errors='ignore')
+                    all_rows.append(row)
                     logging.info(f"DEBUG: Found stats for {player_name} in {season_str} on attempt {attempt+1}. Appending row.")
-                    break # Break retry loop if successful for this season
+                    break # Break retry loop if successful
                 else:
                     logging.info(f"DEBUG: Player {player_name} not found in {season_str} stats (after getting season data) on attempt {attempt+1}. Retrying...")
                     time.sleep(1)
-                    continue
+                    continue # Go to next attempt
 
             except Exception as e:
                 logging.warning(f"DEBUG: Exception on attempt {attempt+1} when fetching {season_str} {'playoff' if playoffs else 'regular season'} stats for {player_name}: {e}")
                 time.sleep(1) # Wait before next retry
-                if attempt == 2: # If last attempt failed for this season
+                if attempt == 2: # If last attempt failed
                     logging.error(f"DEBUG: All 3 attempts failed for {player_name} in {season_str}. Giving up on this season.")
                 continue # Go to next attempt
 
-        # Add a small delay between processing different seasons for the same player
-        time.sleep(0.5) # Delay between seasons
-
     if not all_rows:
-        logging.warning(f"DEBUG: No stats found for {player_name} in the requested seasons: {seasons_to_fetch}. Returning empty DataFrame.")
+        logging.warning(f"DEBUG: No stats found for {player_name} across all attempted seasons. Returning empty DataFrame.")
         return pd.DataFrame()
     
     df = pd.concat(all_rows, ignore_index=True)
@@ -792,7 +769,7 @@ def get_player_career_stats_brscraper(player_name, seasons_to_fetch: list[str],
         if col not in non_num:
             df[col] = pd.to_numeric(df[col], errors='coerce')
 
-    df['Player'] = player_name
+    df['Player'] = player_name # Ensure original player name is kept
     df = df.replace({np.nan: None})
     return df
 
@@ -970,47 +947,22 @@ def get_player_stats():
         all_player_season_data = []
         players_with_no_data = []
 
-        # Handle individual player stats (1 player, 1 season)
-        if len(selected_players) == 1 and len(selected_seasons) == 1:
-            player_name = selected_players[0]
-            season_str = selected_seasons[0]
-            df_player_data = get_player_career_stats_brscraper(player_name, seasons_to_fetch=[season_str], playoffs=False)
+        for player_name in selected_players:
+            df_player_career = get_player_career_stats_brscraper(player_name, playoffs=False)
             
-            if not df_player_data.empty:
-                all_player_season_data.append(df_player_data)
-                logging.info(f"Successfully retrieved data for {player_name} in {season_str}.")
-            else:
+            if df_player_career.empty:
+                logging.info(f"No career data found for {player_name}. Adding to no_data list.")
                 players_with_no_data.append(player_name)
-                logging.info(f"No data found for {player_name} in {season_str}.")
-
-        # Handle comparison (2 players, 2 seasons)
-        elif len(selected_players) == 2 and len(selected_seasons) == 2:
-            player1_name = selected_players[0]
-            player1_season = selected_seasons[0]
-            player2_name = selected_players[1]
-            player2_season = selected_seasons[1]
-
-            df_player1_data = get_player_career_stats_brscraper(player1_name, seasons_to_fetch=[player1_season], playoffs=False)
-            if not df_player1_data.empty:
-                all_player_season_data.append(df_player1_data)
-                logging.info(f"Successfully retrieved data for {player1_name} in {player1_season}.")
-            else:
-                players_with_no_data.append(player1_name)
-                logging.info(f"No data found for {player1_name} in {player1_season}.")
-
-            # Add a delay between fetching data for player 1 and player 2
-            time.sleep(2) # Introduce a 2-second delay
+                continue
 
-            df_player2_data = get_player_career_stats_brscraper(player2_name, seasons_to_fetch=[player2_season], playoffs=False)
-            if not df_player2_data.empty:
-                all_player_season_data.append(df_player2_data)
-                logging.info(f"Successfully retrieved data for {player2_name} in {player2_season}.")
+            filtered_df = df_player_career[df_player_career['Season'].isin(selected_seasons)].copy()
+            
+            if not filtered_df.empty:
+                all_player_season_data.append(filtered_df)
+                logging.info(f"Successfully filtered data for {player_name} in requested seasons.")
             else:
-                players_with_no_data.append(player2_name)
-                logging.info(f"No data found for {player2_name} in {player2_season}.")
-        else:
-            return jsonify({'error': 'Invalid combination of players and seasons. Expected 1 player/1 season or 2 players/2 seasons.'}), 400
-
+                logging.info(f"No data found for {player_name} in the specific requested seasons: {selected_seasons}. Adding to no_data list.")
+                players_with_no_data.append(player_name)
 
         if not all_player_season_data:
             logging.warning("After processing all players, 'all_player_season_data' is empty. Returning 404.")
@@ -1021,7 +973,11 @@ def get_player_stats():
 
         comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
 
-        basic_display_df = comparison_df_raw.copy()
+        if len(selected_seasons) > 1:
+            basic_display_df = comparison_df_raw.groupby('Player').mean(numeric_only=True).reset_index()
+        else:
+            basic_display_df = comparison_df_raw.copy()
+        
         basic_cols = ['Player', 'Season', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
         basic_display_df = basic_display_df[[c for c in basic_cols if c in basic_display_df.columns]].round(2)
 
@@ -1033,8 +989,13 @@ def get_player_stats():
             lambda r: r['PTS'] / (2 * (r['FGA'] + 0.44 * r['FTA'])) if (r['FGA'] + 0.44 * r['FTA']) else 0,
             axis=1
         )
+        if len(selected_seasons) > 1:
+            advanced_display_df = advanced_df.groupby('Player').mean(numeric_only=True).reset_index()
+        else:
+            advanced_display_df = advanced_df.copy()
+        
         advanced_cols = ['Player', 'Season', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT']
-        advanced_display_df = advanced_df[[c for c in advanced_cols if c in advanced_df.columns]].round(3)
+        advanced_display_df = advanced_display_df[[c for c in advanced_cols if c in advanced_display_df.columns]].round(3)
 
         return jsonify({
             'basic_stats': basic_display_df.to_dict(orient='records'),
@@ -1059,45 +1020,21 @@ def get_player_playoff_stats():
         all_player_season_data = []
         players_with_no_data = []
 
-        if len(selected_players) == 1 and len(selected_seasons) == 1:
-            player_name = selected_players[0]
-            season_str = selected_seasons[0]
-            df_player_data = get_player_career_stats_brscraper(player_name, seasons_to_fetch=[season_str], playoffs=True)
-            
-            if not df_player_data.empty:
-                all_player_season_data.append(df_player_data)
-                logging.info(f"Successfully retrieved playoff data for {player_name} in {season_str}.")
-            else:
+        for player_name in selected_players:
+            df_player_career = get_player_career_stats_brscraper(player_name, playoffs=True)
+            if df_player_career.empty:
+                logging.info(f"No career playoff data found for {player_name}. Adding to no_data list.")
                 players_with_no_data.append(player_name)
-                logging.info(f"No playoff data found for {player_name} in {season_str}.")
-
-        elif len(selected_players) == 2 and len(selected_seasons) == 2:
-            player1_name = selected_players[0]
-            player1_season = selected_seasons[0]
-            player2_name = selected_players[1]
-            player2_season = selected_seasons[1]
-
-            df_player1_data = get_player_career_stats_brscraper(player1_name, seasons_to_fetch=[player1_season], playoffs=True)
-            if not df_player1_data.empty:
-                all_player_season_data.append(df_player1_data)
-                logging.info(f"Successfully retrieved playoff data for {player1_name} in {player1_season}.")
-            else:
-                players_with_no_data.append(player1_name)
-                logging.info(f"No playoff data found for {player1_name} in {player1_season}.")
-
-            # Add a delay between fetching data for player 1 and player 2
-            time.sleep(2) # Introduce a 2-second delay
+                continue
 
-            df_player2_data = get_player_career_stats_brscraper(player2_name, seasons_to_fetch=[player2_season], playoffs=True)
-            if not df_player2_data.empty:
-                all_player_season_data.append(df_player2_data)
-                logging.info(f"Successfully retrieved playoff data for {player2_name} in {player2_season}.")
+            filtered_df = df_player_career[df_player_career['Season'].isin(selected_seasons)].copy()
+            
+            if not filtered_df.empty:
+                all_player_season_data.append(filtered_df)
+                logging.info(f"Successfully filtered playoff data for {player_name} in requested seasons.")
             else:
-                players_with_no_data.append(player2_name)
-                logging.info(f"No playoff data found for {player2_name} in {player2_season}.")
-        else:
-            return jsonify({'error': 'Invalid combination of players and seasons. Expected 1 player/1 season or 2 players/2 seasons.'}), 400
-
+                logging.info(f"No playoff data found for {player_name} in the specific requested seasons: {selected_seasons}. Adding to no_data list.")
+                players_with_no_data.append(player_name)
 
         if not all_player_season_data:
             logging.warning("After processing all players, 'all_player_season_data' is empty for playoffs. Returning 404.")
@@ -1108,7 +1045,11 @@ def get_player_playoff_stats():
 
         comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
 
-        basic_display_df = comparison_df_raw.copy()
+        if len(selected_seasons) > 1:
+            basic_display_df = comparison_df_raw.groupby('Player').mean(numeric_only=True).reset_index()
+        else:
+            basic_display_df = comparison_df_raw.copy()
+        
         basic_cols = ['Player', 'Season', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
         basic_display_df = basic_display_df[[c for c in basic_cols if c in basic_display_df.columns]].round(2)
 
@@ -1120,8 +1061,13 @@ def get_player_playoff_stats():
             lambda r: r['PTS'] / (2 * (r['FGA'] + 0.44 * r['FTA'])) if (r['FGA'] + 0.44 * r['FTA']) else 0,
             axis=1
         )
+        if len(selected_seasons) > 1:
+            advanced_display_df = advanced_df.groupby('Player').mean(numeric_only=True).reset_index()
+        else:
+            advanced_display_df = advanced_df.copy()
+        
         advanced_cols = ['Player', 'Season', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT']
-        advanced_display_df = advanced_df[[c for c in advanced_cols if c in advanced_df.columns]].round(3)
+        advanced_display_df = advanced_display_df[[c for c in advanced_cols if c in advanced_display_df.columns]].round(3)
 
         return jsonify({
             'basic_stats': basic_display_df.to_dict(orient='records'),
@@ -1489,4 +1435,4 @@ def manual_player_compare():
 
 
 if __name__ == '__main__':
-    app.run(debug=True, host="0.0.0.0", port=7860)
+    app.run(debug=True, host="0.0.0.0", port=7860)