Update src/streamlit_app.py

src/streamlit_app.py

@@ -8,14 +8,14 @@ from datetime import datetime
 import plotly.express as px
 import plotly.graph_objects as go
 
-# Import BRScraper - Fixed import
+# Import BRScraper
 try:
-    from basketball_reference_scraper import players, teams, seasons
+    from BRScraper import nba
     BRSCRAPER_AVAILABLE = True
 except ImportError:
     BRSCRAPER_AVAILABLE = False
     # Display error message if BRScraper is not found
-    st.error("BRScraper not found. Please install with: pip install basketball-reference-scraper")
+    st.error("BRScraper not found. Please install with: `pip install BRScraper`")
 
 # Page configuration
 st.set_page_config(
@@ -62,7 +62,7 @@ def get_available_seasons(num_seasons=6):
         end_year = latest_season_end_year - i
         start_year = end_year - 1
         # Use en-dash for consistency with BBR format
-        seasons_list.append(f"{start_year}–{str(end_year)[-2:]}")
+        seasons_list.append(f"{start_year}–{end_year}")
     return sorted(seasons_list, reverse=True) # Sort to show most recent first
 
 @st.cache_data(ttl=3600)
@@ -79,11 +79,11 @@ def get_player_index_brscraper():
         # Example: '2024–25' -> 2025
         latest_season_end_year = int(get_available_seasons(1)[0].split('–')[1])
         
-        # Use seasons.get_stats to get a list of players for the latest season
-        # BRScraper's get_stats returns a 'PLAYER' column
-        df = seasons.get_stats(latest_season_end_year, data_format='per_game', playoffs=False)
+        # Use nba.get_stats to get a list of players for the latest season
+        # BRScraper's get_stats returns a 'Player' column
+        df = nba.get_stats(latest_season_end_year, info='per_game', rename=False)
         
-        if df.empty or 'PLAYER' not in df.columns:
+        if df.empty or 'Player' not in df.columns:
             st.warning(f"BRScraper could not fetch player list for {latest_season_end_year}. Falling back to common players.")
             # Fallback to a hardcoded list of common players for demo
             common_players = [
@@ -95,7 +95,7 @@ def get_player_index_brscraper():
             ]
             return pd.DataFrame({'name': common_players})
         
-        player_names = df['PLAYER'].unique().tolist()
+        player_names = df['Player'].unique().tolist()
         return pd.DataFrame({'name': player_names})
         
     except Exception as e:
@@ -117,22 +117,23 @@ def get_player_career_stats_brscraper(player_name):
         return pd.DataFrame()
     
     try:
-        # BRScraper's players.get_stats returns a DataFrame with career stats
-        df = players.get_stats(player_name, stat_type='PER_GAME')
+        # BRScraper's nba.get_player_stats returns a DataFrame with career stats
+        df = nba.get_player_stats(player_name)
         
         if df.empty:
             return pd.DataFrame()
 
         # Standardize column names from BRScraper output to app's expected format
+        # BRScraper's nba.get_player_stats uses column names like 'FG%', 'TRB', 'Tm', 'Age'
         column_mapping = {
-            'SEASON': 'Season', # BRScraper returns 'SEASON'
+            'Season': 'Season', # BRScraper returns 'Season'
             'G': 'GP', 'GS': 'GS', 'MP': 'MIN',
-            'FG_PCT': 'FG_PCT', 'FG3_PCT': 'FG3_PCT', 'FT_PCT': 'FT_PCT',
+            'FG%': 'FG_PCT', '3P%': 'FG3_PCT', 'FT%': 'FT_PCT',
             'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO',
             'PF': 'PF', 'PTS': 'PTS',
-            'AGE': 'AGE', 'TEAM': 'TEAM_ABBREVIATION', 'POS': 'POSITION',
-            'FG': 'FGM', 'FGA': 'FGA', 'FG3': 'FG3M', 'FG3A': 'FG3A',
-            'FG2': 'FGM2', 'FG2A': 'FGA2', 'FG2_PCT': 'FG2_PCT', 'EFG_PCT': 'EFG_PCT',
+            'Age': 'AGE', 'Tm': 'TEAM_ABBREVIATION', 'Lg': 'LEAGUE_ID', 'Pos': 'POSITION',
+            'FG': 'FGM', 'FGA': 'FGA', '3P': 'FG3M', '3PA': 'FG3A',
+            '2P': 'FGM2', '2PA': 'FGA2', '2P%': 'FG2_PCT', 'eFG%': 'EFG_PCT',
             'FT': 'FTM', 'FTA': 'FTA', 'ORB': 'OREB', 'DRB': 'DREB'
         }
         
@@ -146,8 +147,8 @@ def get_player_career_stats_brscraper(player_name):
             df['Season'] = df['Season'].astype(str).str.replace('-', '–')
         
         # Convert numeric columns
-        # Exclude 'Season', 'TEAM_ABBREVIATION', 'POSITION' as they are strings
-        non_numeric_cols = {'Season', 'TEAM_ABBREVIATION', 'POSITION'}
+        # Exclude 'Season', 'TEAM_ABBREVIATION', 'LEAGUE_ID', 'POSITION' as they are strings
+        non_numeric_cols = {'Season', 'TEAM_ABBREVIATION', 'LEAGUE_ID', 'POSITION'}
         for col in df.columns:
             if col not in non_numeric_cols:
                 df[col] = pd.to_numeric(df[col], errors="coerce")
@@ -164,51 +165,62 @@ def get_player_career_stats_brscraper(player_name):
 @st.cache_data(ttl=300)
 def get_team_season_stats_brscraper(year):
     """
-    Uses BRScraper to get team stats for a given season year.
+    Uses BRScraper to get per-game team stats for a given season year.
     Applies column renaming and numeric conversion.
     """
     if not BRSCRAPER_AVAILABLE:
         return pd.DataFrame()
     
     try:
-        # BRScraper's teams.get_team_stats returns a DataFrame with team stats for the year
-        df = teams.get_team_stats(year, data_format='per_game')
+        # BRScraper's nba.get_stats returns a DataFrame with team stats for the year
+        # This function returns both player and team stats, so we need to filter for teams
+        df = nba.get_stats(year, info='per_game', rename=False)
         
         if df.empty:
             return pd.DataFrame()
 
+        # Filter for team rows. Team rows typically have 'Player' as NaN.
+        # Also, remove any rows that are just headers (e.g., 'Rk' == 'Rk')
+        team_df = df[df['Player'].isna()].copy()
+        team_df = team_df[team_df['Rk'].astype(str).str.lower() != 'rk'].copy() # Remove header rows if they slipped through
+
+        if team_df.empty:
+            st.warning(f"Could not reliably identify team rows for year {year}. Returning empty DataFrame.")
+            return pd.DataFrame()
+
         # Standardize column names from BRScraper output
+        # BRScraper's nba.get_stats for teams uses 'Tm', 'W/L%', etc.
         column_mapping = {
             'G': 'GP', 'MP': 'MIN',
-            'FG_PCT': 'FG_PCT', 'FG3_PCT': 'FG3_PCT', 'FT_PCT': 'FT_PCT',
+            'FG%': 'FG_PCT', '3P%': 'FG3_PCT', 'FT%': 'FT_PCT',
             'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO',
             'PF': 'PF', 'PTS': 'PTS',
-            'RK': 'RANK', 'W': 'WINS', 'L': 'LOSSES', 'W_L_PCT': 'WIN_LOSS_PCT', # BRScraper uses W_L_PCT
-            'FG': 'FGM', 'FGA': 'FGA', 'FG3': 'FG3M', 'FG3A': 'FG3A',
-            'FG2': 'FGM2', 'FG2A': 'FGA2', 'FG2_PCT': 'FG2_PCT', 'EFG_PCT': 'EFG_PCT',
+            'Rk': 'RANK', 'W': 'WINS', 'L': 'LOSSES', 'W/L%': 'WIN_LOSS_PCT',
+            'FG': 'FGM', 'FGA': 'FGA', '3P': 'FG3M', '3PA': 'FG3A',
+            '2P': 'FGM2', '2PA': 'FGA2', '2P%': 'FG2_PCT', 'eFG%': 'EFG_PCT',
             'FT': 'FTM', 'FTA': 'FTA', 'ORB': 'OREB', 'DRB': 'DREB',
-            'TEAM': 'Team' # BRScraper returns 'TEAM'
+            'Tm': 'Team' # BRScraper returns 'Tm' for team abbreviation
         }
         
         for old_col, new_col in column_mapping.items():
-            if old_col in df.columns:
-                df = df.rename(columns={old_col: new_col})
+            if old_col in team_df.columns:
+                team_df = team_df.rename(columns={old_col: new_col})
 
         # Convert numeric columns
         # Exclude 'Team' and 'RANK' as they are strings/identifiers
         non_numeric_cols = {"Team", "RANK"}
-        for col in df.columns:
+        for col in team_df.columns:
             if col not in non_numeric_cols:
-                df[col] = pd.to_numeric(df[col], errors="coerce")
+                team_df[col] = pd.to_numeric(team_df[col], errors="coerce")
         
         # Ensure 'Team' column is present and clean it (remove asterisks)
-        if 'Team' in df.columns:
-            df['Team'] = df['Team'].astype(str).str.replace('*', '', regex=False).str.strip()
+        if 'Team' in team_df.columns:
+            team_df['Team'] = team_df['Team'].astype(str).str.replace('*', '', regex=False).str.strip()
         else:
             st.warning(f"Could not find 'Team' column in BRScraper output for year {year}.")
             return pd.DataFrame()
 
-        return df
+        return team_df
         
     except Exception as e:
         st.error(f"Error fetching team stats for {year} with BRScraper: {e}")
@@ -305,8 +317,10 @@ def create_radar_chart(player_stats, categories):
 # Main App Structure
 # —————————————————————————————————————————————————————————————————————————————
 def main():
+    # Check if BRScraper is available at the start of main
+    # This flag is set globally based on the import attempt
     if not BRSCRAPER_AVAILABLE:
-        st.warning("⚠️ BRScraper is not installed. Some features may be limited. Install with: `pip install basketball-reference-scraper`")
+        st.warning("⚠️ BRScraper is not installed. Some features may be limited. Install with: `pip install BRScraper`")
     
     st.markdown('<h1 class="main-header">🏀 NBA Analytics Hub (BBR Edition)</h1>', unsafe_allow_html=True)
     st.sidebar.title("Navigation")
@@ -333,7 +347,7 @@ def player_vs_player():
     st.markdown('<h2 class="section-header">Player vs Player Comparison</h2>', unsafe_allow_html=True)
     
     if not BRSCRAPER_AVAILABLE:
-        st.error("BRScraper is required for this feature. Please install basketball-reference-scraper.")
+        st.error("BRScraper is required for this feature. Please install BRScraper.")
         return
     
     idx = get_player_index_brscraper()
@@ -349,7 +363,7 @@ def player_vs_player():
             return
 
         stats_tabs = st.tabs(["Basic Stats", "Advanced Stats", "Visualizations"])
-        all_player_season_data = []
+        all_player_season_data = [] # To store individual season rows for each player
         players_with_no_data = []
 
         with st.spinner("Fetching player data..."):
@@ -357,6 +371,8 @@ def player_vs_player():
                 df_player_career = get_player_career_stats_brscraper(player_name)
 
                 if not df_player_career.empty:
+                    # Filter for selected seasons. The player_season_stats function
+                    # already ensures the 'Season' column uses en-dashes.
                     filtered_df = df_player_career[df_player_career['Season'].isin(selected_seasons)].copy()
 
                     if not filtered_df.empty:
@@ -366,17 +382,21 @@ def player_vs_player():
                 else:
                     players_with_no_data.append(player_name)
 
+        # Report on players with no data for selected seasons
         if players_with_no_data:
-            st.info(f"No data found for the selected seasons ({', '.join(selected_seasons)}) for: {', '.join(players_with_no_data)}.")
+            st.info(f"No data found for the selected seasons ({', '.join(selected_seasons)}) for: {', '.join(players_with_no_data)}. This might be because the season hasn't started or data is not yet available, or the player name was not found by BRScraper.")
 
         if not all_player_season_data:
-            st.error("No data available for any of the selected players and seasons to display.")
+            st.error("No data available for any of the selected players and seasons to display. Please adjust your selections.")
             return
 
+        # Concatenate all collected season data into one DataFrame
         comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
 
         with stats_tabs[0]:
             st.subheader("Basic Statistics")
+            # Group by player and average for the basic stats table if multiple seasons are selected
+            # Otherwise, show individual season stats if only one season is selected
             if len(selected_seasons) > 1:
                 basic_display_df = comparison_df_raw.groupby('Player').mean(numeric_only=True).reset_index()
                 basic_cols = ['Player', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
@@ -393,6 +413,7 @@ def player_vs_player():
                 advanced_df = comparison_df_raw.copy()
 
                 # Calculate TS% (True Shooting Percentage)
+                # Ensure FGA and FTA are numeric and not zero to avoid division by zero
                 advanced_df['FGA'] = pd.to_numeric(advanced_df['FGA'], errors='coerce').fillna(0)
                 advanced_df['FTA'] = pd.to_numeric(advanced_df['FTA'], errors='coerce').fillna(0)
                 advanced_df['PTS'] = pd.to_numeric(advanced_df['PTS'], errors='coerce').fillna(0)
@@ -418,14 +439,16 @@ def player_vs_player():
             st.subheader("Player Comparison Charts")
 
             if not comparison_df_raw.empty:
-                metrics = ['PTS', 'REB', 'AST', 'FG_PCT', 'FG3_PCT', 'FT_PCT', 'STL', 'BLK']
+                metrics = ['PTS', 'REB', 'AST', 'FG_PCT', '3P_PCT', 'FT_PCT', 'STL', 'BLK']
                 available_metrics = [m for m in metrics if m in comparison_df_raw.columns]
 
                 if available_metrics:
                     selected_metric = st.selectbox("Select Metric to Visualize", available_metrics)
 
                     if selected_metric:
+                        # Determine if we are showing a trend for one player or comparison for multiple
                         if len(selected_players) == 1 and len(selected_seasons) > 1:
+                            # Show trend over seasons for one player
                             player_trend_df = comparison_df_raw[comparison_df_raw['Player'] == selected_players[0]].sort_values(by='Season')
                             fig = px.line(
                                 player_trend_df,
@@ -435,6 +458,7 @@ def player_vs_player():
                                 markers=True
                             )
                         else:
+                            # Average over selected seasons for multiple players for bar chart
                             avg_comparison_df = comparison_df_raw.groupby('Player')[available_metrics].mean(numeric_only=True).reset_index()
                             fig = px.bar(
                                 avg_comparison_df,
@@ -445,12 +469,13 @@ def player_vs_player():
                             )
                         st.plotly_chart(fig, use_container_width=True)
 
-                        # Radar chart
+                        # Radar chart for multi-metric comparison
                         radar_metrics_for_chart = ['PTS', 'REB', 'AST', 'STL', 'BLK']
                         radar_metrics_for_chart = [m for m in radar_metrics_for_chart if m in comparison_df_raw.columns]
 
                         if len(radar_metrics_for_chart) >= 3:
                             radar_data = {}
+                            # Use the averaged data for radar chart if multiple seasons
                             if len(selected_seasons) > 1:
                                 radar_source_df = comparison_df_raw.groupby('Player')[radar_metrics_for_chart].mean(numeric_only=True).reset_index()
                             else:
@@ -458,13 +483,14 @@ def player_vs_player():
 
                             scaled_radar_df = radar_source_df.copy()
 
+                            # Simple min-max scaling for radar chart visualization (0-100)
                             for col in radar_metrics_for_chart:
                                 min_val = scaled_radar_df[col].min()
                                 max_val = scaled_radar_df[col].max()
                                 if max_val > min_val:
                                     scaled_radar_df[col] = ((scaled_radar_df[col] - min_val) / (max_val - min_val)) * 100
                                 else:
-                                    scaled_radar_df[col] = 0
+                                    scaled_radar_df[col] = 0 # Default if all values are the same
 
                             for _, row in scaled_radar_df.iterrows():
                                 radar_data[row['Player']] = {
@@ -474,6 +500,15 @@ def player_vs_player():
                             if radar_data:
                                 radar_fig = create_radar_chart(radar_data, radar_metrics_for_chart)
                                 st.plotly_chart(radar_fig, use_container_width=True)
+                            else:
+                                st.info("Could not generate radar chart data.")
+                        else:
+                            st.info("Select at least 3 common metrics for a radar chart (e.g., PTS, REB, AST, STL, BLK).")
+                else:
+                    st.info("No common metrics available for visualization.")
+            else:
+                st.info("No data available for visualizations.")
+
 
 def team_vs_team():
     st.markdown('<h2 class="section-header">Team vs Team Analysis</h2>', unsafe_allow_html=True)
@@ -488,15 +523,15 @@ def team_vs_team():
         return
         
     selected_season_str = st.selectbox("Select Season", available_seasons, index=0)
-    # Correctly extract the full end year (e.g., "2024–25" -> 2025) for BRScraper
+    # Extract the end year from the season string (e.g., "2024–25" -> 2025)
     year_for_team_stats = int(selected_season_str.split('–')[1])
 
-    tm_df = get_team_season_stats_brscraper(year_for_team_stats)
+    tm_df = get_team_season_stats_brscraper(year_for_team_stats) # Use BRScraper for team stats
     if tm_df.empty:
-        st.info(f"No team data available for the {selected_season_str} season.")
+        st.info(f"No team data available for the {selected_season_str} season. This might be because the season hasn't started or data is not yet available, or BRScraper could not fetch it.")
         return
 
-    teams = tm_df['Team'].unique().tolist()
+    teams = tm_df['Team'].unique().tolist() # Use 'Team' column from BRScraper output
     selected_teams = st.multiselect("Select Teams (up to 4)", teams, max_selections=4)
 
     if st.button("Run Comparison"):
@@ -509,45 +544,51 @@ def team_vs_team():
 
         with st.spinner("Fetching team data..."):
             for t in selected_teams:
-                df = tm_df[tm_df.Team == t].copy()
+                df = tm_df[tm_df.Team == t].copy() # Filter by 'Team' column
                 if not df.empty:
-                    df['Season'] = selected_season_str
-                    stats.append(df.iloc[0].to_dict())
+                    # For team stats, we usually get one row per team per season from team_per_game
+                    # So, no need for .mean() here, just take the row.
+                    df['Season'] = selected_season_str # Add 'Season' column
+                    stats.append(df.iloc[0].to_dict()) # Convert the single row to dict
                 else:
                     teams_with_no_data.append(t)
 
         if teams_with_no_data:
-            st.info(f"No data found for: {', '.join(teams_with_no_data)}")
+            st.info(f"No data found for the selected season ({selected_season_str}) for: {', '.join(teams_with_no_data)}. This might be because the season hasn't started or data is not yet available.")
 
         if not stats:
-            st.error("No data available for the selected teams.")
+            st.error("No data available for the selected teams to display. Please adjust your selections.")
             return
 
         comp = pd.DataFrame(stats)
-        for col in ['PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FG3_PCT', 'FT_PCT']:
+        # Ensure numeric columns are actually numeric for display and calculations
+        for col in ['PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', '3P_PCT', 'FT_PCT']:
             if col in comp.columns:
                 comp[col] = pd.to_numeric(comp[col], errors='coerce')
 
         st.subheader("Team Statistics Comparison")
-        cols = ['Team', 'Season', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FG3_PCT', 'FT_PCT']
+        cols = ['Team', 'Season', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', '3P_PCT', 'FT_PCT']
         display_cols = [col for col in cols if col in comp.columns]
         st.dataframe(comp[display_cols].round(2), use_container_width=True)
 
         st.subheader("Team Performance Visualization")
-        metric_options = ['PTS', 'REB', 'AST', 'FG_PCT', 'FG3_PCT', 'FT_PCT']
+        metric_options = ['PTS', 'REB', 'AST', 'FG_PCT', '3P_PCT', 'FT_PCT']
         available_metrics = [m for m in metric_options if m in comp.columns]
 
         if available_metrics:
             selected_metric = st.selectbox("Select Metric", available_metrics)
+
             fig = px.bar(
                 comp,
                 x='Team',
                 y=selected_metric,
-                color='Team',
+                color='Team', # Color by team for clarity
                 title=f"Team {selected_metric} Comparison ({selected_season_str} Season)",
                 barmode='group'
             )
             st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.info("No common metrics available for visualization.")
 
 def awards_predictor():
     st.markdown('<h2 class="section-header">NBA Awards Predictor</h2>', unsafe_allow_html=True)