Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,13 +4,18 @@ import numpy as np
 import requests
 import os
 from datetime import datetime
-from bs4 import BeautifulSoup, Comment # Keep Comment for parse_table if needed, though BRScraper handles it
-import re
+# Removed BeautifulSoup, Comment, re as BRScraper handles parsing
 import plotly.express as px
 import plotly.graph_objects as go
 
-# Import BRScraper
-from BRScraper import nba
+# Import BRScraper - Fixed import
+try:
+    from basketball_reference_scraper import players, teams, seasons
+    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")
 
 # Page configuration
 st.set_page_config(
@@ -56,7 +61,8 @@ def get_available_seasons(num_seasons=6):
     for i in range(num_seasons):
         end_year = latest_season_end_year - i
         start_year = end_year - 1
-        seasons_list.append(f"{start_year}–{end_year}")
+        # Use en-dash for consistency with BBR format
+        seasons_list.append(f"{start_year}–{str(end_year)[-2:]}")
     return sorted(seasons_list, reverse=True) # Sort to show most recent first
 
 @st.cache_data(ttl=3600)
@@ -65,20 +71,41 @@ def get_player_index_brscraper():
     Uses BRScraper to get a list of players from a recent season's stats.
     This serves as our player index for the multiselect.
     """
-    latest_season_end_year = int(get_available_seasons(1)[0].split('–')[1])
+    if not BRSCRAPER_AVAILABLE:
+        return pd.DataFrame(columns=['name'])
+    
     try:
-        # Get per_game stats for the latest season to get a list of active players
-        df = nba.get_stats(latest_season_end_year, info='per_game', rename=False)
-        if df.empty:
-            st.error(f"Could not fetch player list for {latest_season_end_year} from BRScraper.")
-            return pd.DataFrame(columns=['name']) # Return empty with 'name' column
+        # Get the end year of the most recent season for 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)
         
-        # Extract unique player names
-        player_names = df['Player'].unique().tolist()
+        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 = [
+                'LeBron James', 'Stephen Curry', 'Kevin Durant', 'Giannis Antetokounmpo',
+                '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'
+            ]
+            return pd.DataFrame({'name': common_players})
+        
+        player_names = df['PLAYER'].unique().tolist()
         return pd.DataFrame({'name': player_names})
+        
     except Exception as e:
-        st.error(f"Error fetching player index with BRScraper: {e}")
-        return pd.DataFrame(columns=['name'])
+        st.error(f"Error fetching player index with BRScraper: {e}. Falling back to common players.")
+        # Fallback to hardcoded list
+        fallback_players = [
+            'LeBron James', 'Stephen Curry', 'Kevin Durant', 'Giannis Antetokounmpo',
+            'Nikola Jokic', 'Joel Embiid', 'Jayson Tatum', 'Luka Doncic'
+        ]
+        return pd.DataFrame({'name': fallback_players})
 
 @st.cache_data(ttl=300)
 def get_player_career_stats_brscraper(player_name):
@@ -86,21 +113,26 @@ def get_player_career_stats_brscraper(player_name):
     Uses BRScraper to get a player's career stats.
     Applies column renaming and numeric conversion.
     """
+    if not BRSCRAPER_AVAILABLE:
+        return pd.DataFrame()
+    
     try:
-        df = nba.get_player_stats(player_name)
+        # BRScraper's players.get_stats returns a DataFrame with career stats
+        df = players.get_stats(player_name, stat_type='PER_GAME')
+        
         if df.empty:
             return pd.DataFrame()
 
-        # Standardize column names
+        # Standardize column names from BRScraper output to app's expected format
         column_mapping = {
-            'Season': 'Season', # Keep as is, will convert to en-dash later
+            'SEASON': 'Season', # BRScraper returns 'SEASON'
             'G': 'GP', 'GS': 'GS', 'MP': 'MIN',
-            'FG%': 'FG_PCT', '3P%': 'FG3_PCT', 'FT%': 'FT_PCT',
+            'FG_PCT': 'FG_PCT', 'FG3_PCT': 'FG3_PCT', 'FT_PCT': 'FT_PCT',
             'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO',
             'PF': 'PF', 'PTS': 'PTS',
-            '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',
+            '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',
             'FT': 'FTM', 'FTA': 'FTA', 'ORB': 'OREB', 'DRB': 'DREB'
         }
         
@@ -114,7 +146,8 @@ def get_player_career_stats_brscraper(player_name):
             df['Season'] = df['Season'].astype(str).str.replace('-', '–')
         
         # Convert numeric columns
-        non_numeric_cols = {'Season', 'TEAM_ABBREVIATION', 'LEAGUE_ID', 'POSITION', 'Player'}
+        # Exclude 'Season', 'TEAM_ABBREVIATION', 'POSITION' as they are strings
+        non_numeric_cols = {'Season', 'TEAM_ABBREVIATION', 'POSITION'}
         for col in df.columns:
             if col not in non_numeric_cols:
                 df[col] = pd.to_numeric(df[col], errors="coerce")
@@ -123,6 +156,7 @@ def get_player_career_stats_brscraper(player_name):
         df['Player'] = player_name
 
         return df
+        
     except Exception as e:
         st.error(f"Error fetching stats for {player_name} with BRScraper: {e}")
         return pd.DataFrame()
@@ -130,89 +164,52 @@ def get_player_career_stats_brscraper(player_name):
 @st.cache_data(ttl=300)
 def get_team_season_stats_brscraper(year):
     """
-    Uses BRScraper to get per-game team stats for a given season year.
+    Uses BRScraper to get team stats for a given season year.
     Applies column renaming and numeric conversion.
     """
+    if not BRSCRAPER_AVAILABLE:
+        return pd.DataFrame()
+    
     try:
-        df = nba.get_stats(year, info='per_game', rename=False)
-        if df.empty:
-            return pd.DataFrame()
-
-        # Filter for team rows (BRScraper's get_stats includes player rows too)
-        # Team rows typically have 'Rk' (Rank) as NaN or a non-numeric value after cleaning
-        # Or they are the first few rows before player data starts.
-        # A common pattern is that team rows have 'Player' as NaN or a team name.
-        # Let's assume 'Player' column is NaN for team rows, or 'Tm' is not NaN.
-        
-        # First, standardize column names to make filtering easier
-        df.columns = [str(col).strip() for col in df.columns]
+        # 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')
         
-        # Rename 'Tm' to 'Team' for easier filtering if it exists
-        if 'Tm' in df.columns:
-            df = df.rename(columns={'Tm': 'Team'})
-
-        # Filter out player rows. Player rows usually have a non-null 'Player' column.
-        # Team rows might have 'Player' as NaN or the team name itself.
-        # A more robust way is to look for rows where 'Rk' is not numeric (e.g., 'Rk' for team totals)
-        # Or where 'Player' is NaN and 'Team' is not NaN.
-        
-        # Let's try to identify team rows by checking if 'Player' column is missing or NaN
-        # and 'Team' column is present and not NaN.
-        if 'Player' in df.columns:
-            # Filter out rows where 'Player' is not NaN (these are player stats)
-            team_df = df[df['Player'].isna()].copy()
-        else:
-            # If no 'Player' column, assume all rows are team-related, or need further inspection
-            team_df = df.copy()
-
-        # Further refine: ensure 'Team' column is present and not NaN
-        if 'Team' not in team_df.columns or team_df['Team'].isna().all():
-            # Fallback: if 'Team' column is problematic, try to find rows where 'Rk' is 'Rk' (header)
-            # or where 'Rk' is not a number (e.g., 'Rk' for team totals)
-            if 'Rk' in df.columns:
-                team_df = df[pd.to_numeric(df['Rk'], errors='coerce').isna()].copy()
-                if 'Player' in team_df.columns: # Remove Player column if it's still there
-                    team_df = team_df.drop(columns=['Player'])
-            else:
-                st.warning(f"Could not reliably identify team rows for year {year}. Returning all data.")
-                team_df = df.copy() # Fallback to returning all data if filtering is hard
-
-        if team_df.empty:
+        if df.empty:
             return pd.DataFrame()
 
-        # Standardize column names
+        # Standardize column names from BRScraper output
         column_mapping = {
             'G': 'GP', 'MP': 'MIN',
-            'FG%': 'FG_PCT', '3P%': 'FG3_PCT', 'FT%': 'FT_PCT',
+            'FG_PCT': 'FG_PCT', 'FG3_PCT': 'FG3_PCT', 'FT_PCT': 'FT_PCT',
             'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO',
             'PF': 'PF', 'PTS': 'PTS',
-            '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'
+            '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',
+            'FT': 'FTM', 'FTA': 'FTA', 'ORB': 'OREB', 'DRB': 'DREB',
+            'TEAM': 'Team' # BRScraper returns 'TEAM'
         }
         
         for old_col, new_col in column_mapping.items():
-            if old_col in team_df.columns:
-                team_df = team_df.rename(columns={old_col: new_col})
+            if old_col in df.columns:
+                df = df.rename(columns={old_col: new_col})
 
         # Convert numeric columns
-        non_numeric_cols = {"Team", "Tm", "RANK"} # 'Team' or 'Tm' will be the team identifier
-        for col in team_df.columns:
+        # Exclude 'Team' and 'RANK' as they are strings/identifiers
+        non_numeric_cols = {"Team", "RANK"}
+        for col in df.columns:
             if col not in non_numeric_cols:
-                team_df[col] = pd.to_numeric(team_df[col], errors="coerce")
+                df[col] = pd.to_numeric(df[col], errors="coerce")
         
-        # Ensure 'Team' column is present and clean it
-        if 'Team' in team_df.columns:
-            team_df['Team'] = team_df['Team'].astype(str).str.replace('*', '').str.strip()
-        elif 'Tm' in team_df.columns: # Fallback if 'Team' was not the original name
-            team_df = team_df.rename(columns={'Tm': 'Team'})
-            team_df['Team'] = team_df['Team'].astype(str).str.replace('*', '').str.strip()
+        # 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()
         else:
-            st.warning(f"Could not find a 'Team' or 'Tm' column in the processed team data for {year}.")
+            st.warning(f"Could not find 'Team' column in BRScraper output for year {year}.")
             return pd.DataFrame()
 
-        return team_df
+        return df
+        
     except Exception as e:
         st.error(f"Error fetching team stats for {year} with BRScraper: {e}")
         return pd.DataFrame()
@@ -228,7 +225,7 @@ def ask_perp(prompt, system="You are a helpful NBA analyst AI.", max_tokens=500,
         return ""
     hdr = {'Authorization':f'Bearer {PERP_KEY}','Content-Type':'application/json'}
     payload = {
-      "model":"sonar-medium-online", # Changed to a commonly available online model
+      "model":"sonar-medium-online", # Using a commonly available online model
       "messages":[{"role":"system","content":system},{"role":"user","content":prompt}],
       "max_tokens":max_tokens, "temperature":temp
     }
@@ -238,9 +235,9 @@ def ask_perp(prompt, system="You are a helpful NBA analyst AI.", max_tokens=500,
         return r.json().get("choices", [{}])[0].get("message",{}).get("content","")
     except requests.exceptions.RequestException as e:
         error_message = f"Error communicating with Perplexity API: {e}"
-        if r.response is not None:
+        if hasattr(e, 'response') and e.response is not None:
             try:
-                error_detail = r.response.json().get("error", {}).get("message", r.response.text)
+                error_detail = e.response.json().get("error", {}).get("message", e.response.text)
                 error_message = f"Perplexity API error: {error_detail}"
             except ValueError:
                 error_message = f"Perplexity API error: {r.response.status_code} - {r.response.reason}"
@@ -251,16 +248,16 @@ def ask_perp(prompt, system="You are a helpful NBA analyst AI.", max_tokens=500,
         return ""
 
 # —————————————————————————————————————————————————————————————————————————————
-# Plotting functions (retained from previous version)
+# Plotting functions
 def create_comparison_chart(data, players_names, metric):
     """Create comparison chart for players"""
     fig = go.Figure()
 
     for i, player in enumerate(players_names):
-        if player in data['Player'].values: # Changed to 'Player' column
+        if player in data['Player'].values:
             player_data = data[data['Player'] == player]
             fig.add_trace(go.Scatter(
-                x=player_data['Season'], # Changed to 'Season' column
+                x=player_data['Season'],
                 y=player_data[metric],
                 mode='lines+markers',
                 name=player,
@@ -282,7 +279,6 @@ def create_radar_chart(player_stats, categories):
     fig = go.Figure()
 
     for player_name, stats in player_stats.items():
-        # Ensure all categories are present, default to 0 if not
         r_values = [stats.get(cat, 0) for cat in categories]
 
         fig.add_trace(go.Scatterpolar(
@@ -297,7 +293,6 @@ def create_radar_chart(player_stats, categories):
         polar=dict(
             radialaxis=dict(
                 visible=True,
-                # The range should be adjusted based on the scaled data (0-100)
                 range=[0, 100]
             )),
         showlegend=True,
@@ -310,6 +305,9 @@ def create_radar_chart(player_stats, categories):
 # Main App Structure
 # —————————————————————————————————————————————————————————————————————————————
 def main():
+    if not BRSCRAPER_AVAILABLE:
+        st.warning("⚠️ BRScraper is not installed. Some features may be limited. Install with: `pip install basketball-reference-scraper`")
+    
     st.markdown('<h1 class="main-header">🏀 NBA Analytics Hub (BBR Edition)</h1>', unsafe_allow_html=True)
     st.sidebar.title("Navigation")
     page = st.sidebar.radio("", [
@@ -333,12 +331,17 @@ def main():
 # —————————————————————————————————————————————————————————————————————————————
 def player_vs_player():
     st.markdown('<h2 class="section-header">Player vs Player Comparison</h2>', unsafe_allow_html=True)
-    idx = get_player_index_brscraper() # Use BRScraper for player index
+    
+    if not BRSCRAPER_AVAILABLE:
+        st.error("BRScraper is required for this feature. Please install basketball-reference-scraper.")
+        return
+    
+    idx = get_player_index_brscraper()
     names = idx['name'].tolist()
     selected_players = st.multiselect("Select Players (up to 4)", names, max_selections=4)
 
     available_seasons = get_available_seasons()
-    selected_seasons = st.multiselect("Select Seasons", available_seasons, default=[available_seasons[0]])
+    selected_seasons = st.multiselect("Select Seasons", available_seasons, default=[available_seasons[0]] if available_seasons else [])
 
     if st.button("Run Comparison"):
         if not selected_players:
@@ -346,7 +349,7 @@ def player_vs_player():
             return
 
         stats_tabs = st.tabs(["Basic Stats", "Advanced Stats", "Visualizations"])
-        all_player_season_data = [] # To store individual season rows for each player
+        all_player_season_data = []
         players_with_no_data = []
 
         with st.spinner("Fetching player data..."):
@@ -354,33 +357,26 @@ 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:
-                        # 'Player' column is already added by get_player_career_stats_brscraper
                         all_player_season_data.append(filtered_df)
                     else:
                         players_with_no_data.append(player_name)
                 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)}. This might be because the season hasn't started or data is not yet available, or the player name was not found by BRScraper.")
+            st.info(f"No data found for the selected seasons ({', '.join(selected_seasons)}) for: {', '.join(players_with_no_data)}.")
 
         if not all_player_season_data:
-            st.error("No data available for any of the selected players and seasons to display. Please adjust your selections.")
+            st.error("No data available for any of the selected players and seasons to display.")
             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']
@@ -397,7 +393,6 @@ 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)
@@ -423,16 +418,14 @@ def player_vs_player():
             st.subheader("Player Comparison Charts")
 
             if not comparison_df_raw.empty:
-                metrics = ['PTS', 'REB', 'AST', 'FG_PCT', '3P_PCT', 'FT_PCT', 'STL', 'BLK']
+                metrics = ['PTS', 'REB', 'AST', 'FG_PCT', 'FG3_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,
@@ -442,7 +435,6 @@ 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,
@@ -453,13 +445,12 @@ def player_vs_player():
                             )
                         st.plotly_chart(fig, use_container_width=True)
 
-                        # Radar chart for multi-metric comparison
+                        # Radar chart
                         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:
@@ -467,14 +458,13 @@ 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 # Default if all values are the same
+                                    scaled_radar_df[col] = 0
 
                             for _, row in scaled_radar_df.iterrows():
                                 radar_data[row['Player']] = {
@@ -484,31 +474,29 @@ 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)
 
+    if not BRSCRAPER_AVAILABLE:
+        st.error("BRScraper is required for this feature.")
+        return
+
     available_seasons = get_available_seasons()
+    if not available_seasons:
+        st.error("No seasons available.")
+        return
+        
     selected_season_str = st.selectbox("Select Season", available_seasons, index=0)
-
-    # Extract the end year from the season string (e.g., "2024–25" -> 2025)
+    # Correctly extract the full end year (e.g., "2024–25" -> 2025) for BRScraper
     year_for_team_stats = int(selected_season_str.split('–')[1])
 
-    tm_df = get_team_season_stats_brscraper(year_for_team_stats) # Use BRScraper for team stats
+    tm_df = get_team_season_stats_brscraper(year_for_team_stats)
     if tm_df.empty:
-        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.")
+        st.info(f"No team data available for the {selected_season_str} season.")
         return
 
-    teams = tm_df['Team'].unique().tolist() # Use 'Team' column from BRScraper output
+    teams = tm_df['Team'].unique().tolist()
     selected_teams = st.multiselect("Select Teams (up to 4)", teams, max_selections=4)
 
     if st.button("Run Comparison"):
@@ -521,108 +509,103 @@ def team_vs_team():
 
         with st.spinner("Fetching team data..."):
             for t in selected_teams:
-                df = tm_df[tm_df.Team == t].copy() # Filter by 'Team' column
+                df = tm_df[tm_df.Team == t].copy()
                 if not df.empty:
-                    # 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
+                    df['Season'] = selected_season_str
+                    stats.append(df.iloc[0].to_dict())
                 else:
                     teams_with_no_data.append(t)
 
         if 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.")
+            st.info(f"No data found for: {', '.join(teams_with_no_data)}")
 
         if not stats:
-            st.error("No data available for the selected teams to display. Please adjust your selections.")
+            st.error("No data available for the selected teams.")
             return
 
         comp = pd.DataFrame(stats)
-        # Ensure numeric columns are actually numeric for display and calculations
-        for col in ['PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', '3P_PCT', 'FT_PCT']:
+        for col in ['PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FG3_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', '3P_PCT', 'FT_PCT']
+        cols = ['Team', 'Season', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FG3_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', '3P_PCT', 'FT_PCT']
+        metric_options = ['PTS', 'REB', 'AST', 'FG_PCT', 'FG3_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 by team for clarity
+                color='Team',
                 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)
     award = st.selectbox("Select Award", ["MVP","Defensive Player of the Year","Rookie of the Year","6th Man of the Year","All-NBA First Team"])
     st.subheader(f"{award} Criteria")
-    # (same sliders as before…)
+    
     criteria = {}
     if award=="MVP":
-      criteria = {
-        "PPG":st.slider("Min PPG",15.0,35.0,25.0),
-        "Wins":st.slider("Min Team Wins",35,70,50),
-        "PER":st.slider("Min PER",15.0,35.0,25.0),
-        "WS":st.slider("Min Win Shares",5.0,20.0,10.0)
-      }
+        criteria = {
+            "PPG":st.slider("Min PPG",15.0,35.0,25.0),
+            "Wins":st.slider("Min Team Wins",35,70,50),
+            "PER":st.slider("Min PER",15.0,35.0,25.0),
+            "WS":st.slider("Min Win Shares",5.0,20.0,10.0)
+        }
     elif award=="Defensive Player of the Year":
-      criteria = {
-        "BPG":st.slider("Min BPG",0.0,4.0,1.5),
-        "SPG":st.slider("Min SPG",0.0,3.0,1.0),
-        "DefRtgMax":st.slider("Max Def Rating",90.0,120.0,105.0),
-        "DefRankMax":st.slider("Max Team Def Rank",1,30,10)
-      }
+        criteria = {
+            "BPG":st.slider("Min BPG",0.0,4.0,1.5),
+            "SPG":st.slider("Min SPG",0.0,3.0,1.0),
+            "DefRtgMax":st.slider("Max Def Rating",90.0,120.0,105.0),
+            "DefRankMax":st.slider("Max Team Def Rank",1,30,10)
+        }
     else:
-      criteria = {
-        "PPG":st.slider("Min PPG",10.0,30.0,15.0),
-        "Games":st.slider("Min Games",50,82,65),
-        "FG%":st.slider("Min FG%",0.35,0.65,0.45)
-      }
+        criteria = {
+            "PPG":st.slider("Min PPG",10.0,30.0,15.0),
+            "Games":st.slider("Min Games",50,82,65),
+            "FG%":st.slider("Min FG%",0.35,0.65,0.45)
+        }
 
     if st.button("Generate Predictions"):
-        p = f"Predict top 5 {award} based on {criteria}. Focus on 2023-24 season."
+        p = f"Predict top 5 {award} candidates based on {criteria}. Focus on 2024-25 season."
         resp = ask_perp(p, system="You are an NBA awards expert AI.", max_tokens=800)
         st.markdown("### Predictions")
         st.write(resp)
 
 def ai_chat():
     st.markdown('<h2 class="section-header">AI Chat & Insights</h2>', unsafe_allow_html=True)
-    if 'chat_history' not in st.session_state: st.session_state.chat_history=[]
+    
     for msg in st.session_state.chat_history:
         with st.chat_message(msg["role"]):
             st.write(msg["content"])
-    if prompt:=st.chat_input("Ask me anything about NBA…"):
+            
+    if prompt := st.chat_input("Ask me anything about NBA…"):
         st.session_state.chat_history.append({"role":"user","content":prompt})
         with st.chat_message("user"):
-            st.write(prompt) # Display user message immediately
+            st.write(prompt)
         with st.chat_message("assistant"):
             ans = ask_perp(prompt, system="You are an NBA expert analyst AI.", max_tokens=700)
             st.write(ans)
             st.session_state.chat_history.append({"role":"assistant","content":ans})
+    
     st.subheader("Quick Actions")
     c1,c2,c3 = st.columns(3)
     if c1.button("🏆 Contenders"):
-        prompt = "Analyze the current NBA championship contenders for 2024. Who are the top 5 teams and why?"
+        prompt = "Analyze the current NBA championship contenders for 2025. Who are the top 5 teams and why?"
         response = ask_perp(prompt)
         if response: st.write(response)
     if c2.button("⭐ Rising Stars"):
-        prompt = "Who are the most promising young NBA players to watch in 2024? Focus on players 23 and under."
+        prompt = "Who are the most promising young NBA players to watch in 2025? Focus on players 23 and under."
         response = ask_perp(prompt)
         if response: st.write(response)
     if c3.button("📊 Trades"):
@@ -642,7 +625,7 @@ def young_projections():
         yrs = st.number_input("Years in NBA",0,7,2)
         ppg = st.number_input("PPG",0.0,40.0,15.0)
         rpg = st.number_input("RPG",0.0,20.0,5.0)
-        apg = st.number_input("APG",0.0,15.0,3.0)
+        apg = st.number_input("APG",0.0,15.0,3.0) # Completed this line
         if st.button("Generate AI Projection"):
             prompt = (
               f"Analyze and project the future potential of NBA player {sp}: "