Update main.py

main.py

@@ -530,6 +530,7 @@ 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()
 
@@ -658,8 +659,7 @@ def get_player_index_brscraper():
         return df
 
 def _scrape_player_index_brscraper():
-    # 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
+    seasons_to_try_for_index = get_available_seasons_util(num_seasons=3)
     
     for season_str in seasons_to_try_for_index:
         end_year = int(season_str.split('–')[1])
@@ -669,7 +669,6 @@ 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})
@@ -678,35 +677,49 @@ 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', # No accent here, as it will be normalized
-        'Joel Embiid', 'Jayson Tatum', 'Luka Doncic', # No accent here, as it will be normalized
+        'Nikola Jokic',
+        'Joel Embiid', 'Jayson Tatum', 'Luka Doncic',
         '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'
+        'Jalen Brunson', 'Paolo Banchero', 'Franz Wagner', 'Cade Cunningham',
+        'Michael Jordan', 'Kobe Bryant', 'Larry Bird', 'Magic Johnson', 'Kareem Abdul-Jabbar'
     ]
     return pd.DataFrame({'name': common_players})
 
-def get_player_career_stats_brscraper(player_name, seasons_to_check=10, playoffs=False):
+def get_player_career_stats_brscraper(player_name, seasons_to_fetch: list[str], 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 = []
 
-    seasons_to_try = get_available_seasons_util(seasons_to_check)
-    
-    for season_str in seasons_to_try:
+    for season_str in seasons_to_fetch: # Iterate only through the requested seasons
         end_year = int(season_str.split('–')[1])
         
-        # Implement retry logic for each season fetch
+        # 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
         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})...")
@@ -716,40 +729,50 @@ def get_player_career_stats_brscraper(player_name, seasons_to_check=10, playoffs
                 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 # Go to next attempt
+                    continue 
                 
                 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
-                    # Remove the temporary normalized column before appending
-                    row = row.drop(columns=['Player_Normalized'], errors='ignore')
-                    all_rows.append(row)
+                    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
                     logging.info(f"DEBUG: Found stats for {player_name} in {season_str} on attempt {attempt+1}. Appending row.")
-                    break # Break retry loop if successful
+                    break # Break retry loop if successful for this season
                 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 # Go to next attempt
+                    continue
 
             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
+                if attempt == 2: # If last attempt failed for this season
                     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} across all attempted seasons. Returning empty DataFrame.")
+        logging.warning(f"DEBUG: No stats found for {player_name} in the requested seasons: {seasons_to_fetch}. Returning empty DataFrame.")
         return pd.DataFrame()
     
     df = pd.concat(all_rows, ignore_index=True)
@@ -769,7 +792,7 @@ def get_player_career_stats_brscraper(player_name, seasons_to_check=10, playoffs
         if col not in non_num:
             df[col] = pd.to_numeric(df[col], errors='coerce')
 
-    df['Player'] = player_name # Ensure original player name is kept
+    df['Player'] = player_name
     df = df.replace({np.nan: None})
     return df
 
@@ -947,22 +970,47 @@ def get_player_stats():
         all_player_season_data = []
         players_with_no_data = []
 
-        for player_name in selected_players:
-            df_player_career = get_player_career_stats_brscraper(player_name, playoffs=False)
+        # 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)
             
-            if df_player_career.empty:
-                logging.info(f"No career data found for {player_name}. Adding to no_data list.")
+            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:
                 players_with_no_data.append(player_name)
-                continue
+                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}.")
 
-            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.")
+            # Add a delay between fetching data for player 1 and player 2
+            time.sleep(2) # Introduce a 2-second delay
+
+            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}.")
             else:
-                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)
+                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
+
 
         if not all_player_season_data:
             logging.warning("After processing all players, 'all_player_season_data' is empty. Returning 404.")
@@ -973,11 +1021,7 @@ def get_player_stats():
 
         comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
 
-        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_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)
 
@@ -989,13 +1033,8 @@ 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_display_df[[c for c in advanced_cols if c in advanced_display_df.columns]].round(3)
+        advanced_display_df = advanced_df[[c for c in advanced_cols if c in advanced_df.columns]].round(3)
 
         return jsonify({
             'basic_stats': basic_display_df.to_dict(orient='records'),
@@ -1020,21 +1059,45 @@ def get_player_playoff_stats():
         all_player_season_data = []
         players_with_no_data = []
 
-        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)
-                continue
-
-            filtered_df = df_player_career[df_player_career['Season'].isin(selected_seasons)].copy()
+        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 filtered_df.empty:
-                all_player_season_data.append(filtered_df)
-                logging.info(f"Successfully filtered playoff data for {player_name} in requested seasons.")
+            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:
-                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)
+                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
+
+            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}.")
+            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
+
 
         if not all_player_season_data:
             logging.warning("After processing all players, 'all_player_season_data' is empty for playoffs. Returning 404.")
@@ -1045,11 +1108,7 @@ def get_player_playoff_stats():
 
         comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
 
-        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_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)
 
@@ -1061,13 +1120,8 @@ 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_display_df[[c for c in advanced_cols if c in advanced_display_df.columns]].round(3)
+        advanced_display_df = advanced_df[[c for c in advanced_cols if c in advanced_df.columns]].round(3)
 
         return jsonify({
             'basic_stats': basic_display_df.to_dict(orient='records'),