Update main.py

main.py

@@ -946,92 +946,68 @@ def _scrape_player_index_brscraper():
     ]
     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()
-    
-    normalized_player_name = normalize_string(player_name) # Normalize input player name once
     all_rows = []
+    
+    # Normalize the input player name for consistent lookup
+    normalized_player_name = normalize_string(player_name)
 
-    for season_str in seasons_to_fetch:
+    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 based on normalized name, year, and playoff status
-        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}')
-
-        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.")
-                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...")
-
-        # Retry mechanism for scraping
+        # 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})...")
                 
-                # Fetch all player stats for the given season and type (regular/playoffs)
                 df_season = nba.get_stats(end_year, info='per_game', playoffs=playoffs, rename=False)
                 
                 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 before retrying
-                    continue 
+                    time.sleep(1) # Wait a bit before retrying
+                    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 from the scraped data for matching
+                # 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() # Avoid SettingWithCopyWarning
-                    row['Season'] = season_str # Add the season string
-                    row = row.drop(columns=['Player_Normalized'], errors='ignore') # Drop helper column
-                    
-                    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.")
-                    
+                    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)
                     logging.info(f"DEBUG: Found stats for {player_name} in {season_str} on attempt {attempt+1}. Appending row.")
-                    break # Success, exit retry loop for this season
+                    break # Break retry loop if successful
                 else:
-                    # This case means the season data was fetched, but the specific player wasn't in it.
                     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)
-                    # If player not found after fetching season data, retrying might not help unless BRScraper has intermittent issues.
-                    # Consider breaking if player not found in a valid scrape. For now, let it retry.
-                    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 retrying
-                if attempt == 2: # Last attempt failed
+                time.sleep(1) # Wait before next retry
+                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 or next season if all attempts failed
+                continue # Go to next attempt
 
-        time.sleep(0.5) # Small delay between fetching different seasons to be polite to the server
-        
     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)
 
-    # Standardize column names
     mapping = {
         'G':'GP','GS':'GS','MP':'MIN', 'FG%':'FG_PCT','3P%':'FG3_PCT','FT%':'FT_PCT',
         'TRB':'REB','AST':'AST','STL':'STL','BLK':'BLK','TOV':'TO',
@@ -1042,16 +1018,15 @@ def get_player_career_stats_brscraper(player_name, seasons_to_fetch: list[str],
     }
     df = df.rename(columns={o:n for o,n in mapping.items() if o in df.columns})
 
-    # Convert stats to numeric, coercing errors
-    non_num = {'Season','Player','Tm','Lg','Pos'} # Columns that should remain non-numeric
+    non_num = {'Season','Player','Tm','Lg','Pos'}
     for col in df.columns:
         if col not in non_num:
             df[col] = pd.to_numeric(df[col], errors='coerce')
 
-    df['Player'] = player_name # Ensure original (non-normalized) player name is in the final DataFrame
-    df = df.replace({np.nan: None}) # Replace NaN with None for JSON compatibility
+    df['Player'] = player_name # Ensure original player name is kept
+    df = df.replace({np.nan: None})
     return df
-
+    
 def get_dashboard_info_brscraper():
     if not FIREBASE_INITIALIZED:
         logging.error("Firebase not initialized. Dashboard info skipped.")