Bb ref

src/streamlit_app.py

@@ -5,33 +5,14 @@ import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import requests
-from nba_api.stats.endpoints import (
-    playercareerstats, teamdetails, teamgamelog,
-    leaguegamelog, playergamelog, commonplayerinfo, teamplayerdashboard,
-    leagueleaders, playerestimatedmetrics, teamestimatedmetrics
-)
-from nba_api.stats.static import players, teams
-import time
+from bs4 import BeautifulSoup # New import
+import re # New import for regex
+import time # For rate limiting
 from datetime import datetime
 import json
 import os
 
-# --- IMPORTANT: Addressing PermissionError in Containerized Environments ---
-# The error "PermissionError: [Errno 13] Permission denied: '/.streamlit'"
-# occurs because Streamlit tries to write to a non-writable directory.
-# To fix this in your Dockerfile or when running your Docker container,
-# you should set one of the following environment variables:
-#
-# Option 1 (Recommended): Set the HOME environment variable to a writable path.
-#    In your Dockerfile: ENV HOME /tmp
-#    Or when running: docker run -e HOME=/tmp your_image_name
-#
-# Option 2: Disable Streamlit's usage statistics gathering.
-#    In your Dockerfile: ENV STREAMLIT_BROWSER_GATHER_USAGE_STATS=False
-#    Or when running: docker run -e STREAMLIT_BROWSER_GATHER_USAGE_STATS=False your_image_name
-#
-# Option 1 is generally more robust as it provides a writable home directory
-# for any application that might need it.
+
 # -----------------------------------------------------------------------
 
 # Page configuration
@@ -75,6 +56,34 @@ if 'chat_history' not in st.session_state:
 PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_API_KEY")
 PERPLEXITY_API_URL = "https://api.perplexity.ai/chat/completions"
 
+# Base URL for Basketball-Reference
+BBR_BASE_URL = "https://www.basketball-reference.com"
+
+# Hardcoded Team Name to BBR Abbreviation mapping
+# This is more reliable than scraping for team abbreviations.
+TEAM_NAME_TO_BBR_ABBR = {
+    "Atlanta Hawks": "ATL", "Boston Celtics": "BOS", "Brooklyn Nets": "BRK",
+    "Charlotte Hornets": "CHO", "Chicago Bulls": "CHI", "Cleveland Cavaliers": "CLE",
+    "Dallas Mavericks": "DAL", "Denver Nuggets": "DEN", "Detroit Pistons": "DET",
+    "Golden State Warriors": "GSW", "Houston Rockets": "HOU", "Indiana Pacers": "IND",
+    "Los Angeles Clippers": "LAC", "Los Angeles Lakers": "LAL", "Memphis Grizzlies": "MEM",
+    "Miami Heat": "MIA", "Milwaukee Bucks": "MIL", "Minnesota Timberwolves": "MIN",
+    "New Orleans Pelicans": "NOP", "New York Knicks": "NYK", "Oklahoma City Thunder": "OKC",
+    "Orlando Magic": "ORL", "Philadelphia 76ers": "PHI", "Phoenix Suns": "PHO",
+    "Portland Trail Blazers": "POR", "Sacramento Kings": "SAC", "San Antonio Spurs": "SAS",
+    "Toronto Raptors": "TOR", "Utah Jazz": "UTA", "Washington Wizards": "WAS"
+}
+
+# Mapping for season year in BBR URLs (e.g., 2023-24 -> 2024)
+BBR_SEASON_URL_MAP = {
+    "2023-24": "2024", "2022-23": "2023", "2021-22": "2022",
+    "2020-21": "2021", "2019-20": "2020", "2018-19": "2019",
+    "2017-18": "2018", "2016-17": "2017", "2015-16": "2016",
+    "2014-15": "2015", "2013-14": "2014", "2012-13": "2013",
+    "2011-12": "2012", "2010-11": "2011", "2009-10": "2010"
+}
+
+
 # ---------- Perplexity API Functions ----------
 def get_perplexity_response(api_key, prompt, system_message="You are a helpful NBA analyst AI.", max_tokens=500, temperature=0.2):
     """
@@ -89,7 +98,7 @@ def get_perplexity_response(api_key, prompt, system_message="You are a helpful N
         'Content-Type': 'application/json'
     }
     payload = {
-        'model': 'sonar-pro', # Or 'sonar-pro-online' for more advanced capabilities
+        'model': 'sonar-pro', # keep 'sonar-pro' 
         'messages': [
             {'role': 'system', 'content': system_message},
             {'role': 'user', 'content': prompt}
@@ -117,36 +126,236 @@ def get_perplexity_response(api_key, prompt, system_message="You are a helpful N
         st.error(f"An unexpected error occurred with Perplexity API: {e}")
         return None
 
+# ---------- Basketball-Reference Data Fetching Functions ----------
+
 @st.cache_data(ttl=3600)
-def get_all_players():
-    """Get all NBA players"""
-    return players.get_players()
+def get_all_players_bbr():
+    """
+    Scrapes a list of active players from Basketball-Reference's 2024 per-game stats page.
+    Note: This will not get ALL historical players, only those listed on this specific page.
+    For a comprehensive list, a more extensive scrape of player index pages (A-Z) would be needed.
+    """
+    players_list = []
+    url = f"{BBR_BASE_URL}/leagues/NBA_2024_per_game.html" # Using 2024 for current season
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'lxml')
+        table = soup.find('table', {'id': 'per_game_stats'})
+        if table:
+            for row in table.find_all('tr')[1:]: # Skip header row
+                player_name_tag = row.find('a')
+                if player_name_tag:
+                    player_name = player_name_tag.get_text()
+                    # BBR player ID is part of the href (e.g., /players/j/jamesle01.html)
+                    player_bbr_id = player_name_tag['href'].split('/')[-1].replace('.html', '')
+                    players_list.append({'full_name': player_name, 'id': player_bbr_id})
+            st.success(f"Loaded {len(players_list)} players from Basketball-Reference.")
+        else:
+            st.warning(f"Could not find player stats table on {url}")
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching player list from Basketball-Reference: {e}")
+    except Exception as e:
+        st.error(f"An unexpected error occurred while parsing player list: {e}")
+    return players_list
 
 @st.cache_data(ttl=3600)
-def get_all_teams():
-    """Get all NBA teams"""
-    return teams.get_teams()
+def get_all_teams_bbr():
+    """
+    Returns a list of NBA teams using a hardcoded mapping.
+    """
+    teams_list = []
+    for full_name, abbr in TEAM_NAME_TO_BBR_ABBR.items():
+        teams_list.append({'full_name': full_name, 'id': abbr}) # Using abbr as ID for consistency
+    return teams_list
 
 @st.cache_data(ttl=300)
-def get_player_stats(player_id, season_type="Regular Season"):
-    """Get player career stats"""
+def get_player_stats_bbr(player_name, season="2023-24"):
+    """
+    Scrapes player career stats for a given player from Basketball-Reference.
+    Then filters for the specified season.
+    Returns a DataFrame.
+    """
+    # Step 1: Find the player's BBR URL by searching
+    search_url = f"{BBR_BASE_URL}/search/search.fcgi?search={player_name.replace(' ', '+')}"
+    player_url = None
     try:
-        career_stats = playercareerstats.PlayerCareerStats(player_id=player_id)
-        return career_stats.get_data_frames()[0]
+        search_response = requests.get(search_url, timeout=10)
+        search_response.raise_for_status()
+        search_soup = BeautifulSoup(search_response.content, 'lxml')
+        # Look for a link to the player's page in the search results
+        # This assumes the first search result is the correct player
+        player_link_div = search_soup.find('div', {'class': 'search-item-name'})
+        if player_link_div:
+            player_link = player_link_div.find('a')
+            if player_link and player_link['href'].startswith('/players/'):
+                player_url = f"{BBR_BASE_URL}{player_link['href']}"
+        if not player_url:
+            st.warning(f"Could not find Basketball-Reference page for {player_name}.")
+            return pd.DataFrame()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error searching for player {player_name} on Basketball-Reference: {e}")
+        return pd.DataFrame()
     except Exception as e:
-        st.error(f"Error fetching player stats: {str(e)}")
+        st.error(f"An unexpected error occurred during player search for {player_name}: {e}")
+        return pd.DataFrame()
+
+    # Step 2: Scrape the player's page for career stats
+    try:
+        response = requests.get(player_url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'lxml')
+
+        # Basketball-Reference often hides tables in comments.
+        # Find the comment containing the 'per_game' table
+        comment = soup.find(string=lambda text: isinstance(text, str) and 'id="per_game"' in text)
+        if comment:
+            soup_from_comment = BeautifulSoup(comment, 'lxml')
+            table = soup_from_comment.find('table', {'id': 'per_game'})
+        else:
+            table = soup.find('table', {'id': 'per_game'}) # Try direct find if not in comment
+
+        if table:
+            df = pd.read_html(str(table))[0]
+            # Clean up column names (remove special characters, make consistent)
+            # Handle multi-index columns if present (e.g., 'Shooting' -> 'FG', 'FGA')
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = ['_'.join(col).strip() for col in df.columns.values]
+            else:
+                df.columns = [col.strip() for col in df.columns.values]
+
+            # Standardize column names to match original app's expectations
+            df = df.rename(columns={
+                'Season': 'SEASON_ID_BBR', # Keep original BBR season for filtering
+                'Age': 'AGE', 'Tm': 'TEAM_ABBREVIATION', 'Lg': 'LEAGUE_ID', 'Pos': 'POSITION',
+                'G': 'GP', 'GS': 'GS', 'MP': 'MIN',
+                'FG': 'FGM', 'FGA': 'FGA', 'FG%': 'FG_PCT',
+                '3P': 'FG3M', '3PA': 'FG3A', '3P%': 'FG3_PCT',
+                '2P': 'FGM2', '2PA': 'FGA2', '2P%': 'FG2_PCT',
+                'eFG%': 'EFG_PCT', 'FT': 'FTM', 'FTA': 'FTA', 'FT%': 'FT_PCT',
+                'ORB': 'OREB', 'DRB': 'DREB', 'TRB': 'REB', 'AST': 'AST',
+                'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO', 'PF': 'PF', 'PTS': 'PTS'
+            })
+
+            # Filter for the specific season
+            # BBR table's 'Season' column is like '2023-24', not just '2024' for the row.
+            # So, we filter using the original `season` string.
+            filtered_df = df[df['SEASON_ID_BBR'] == season].copy()
+
+            if not filtered_df.empty:
+                # Add PLAYER_NAME and SEASON_ID for consistency with original code
+                filtered_df['PLAYER_NAME'] = player_name
+                filtered_df['SEASON_ID'] = season # Keep original season format
+                return filtered_df
+            else:
+                st.info(f"No stats found for {player_name} in season {season} on Basketball-Reference.")
+                return pd.DataFrame()
+        else:
+            st.warning(f"Could not find 'per_game' table for {player_name} on Basketball-Reference.")
+            return pd.DataFrame()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching player stats for {player_name} from Basketball-Reference: {e}")
+        return pd.DataFrame()
+    except Exception as e:
+        st.error(f"An unexpected error occurred while parsing player stats for {player_name}: {e}")
         return pd.DataFrame()
 
 @st.cache_data(ttl=300)
-def get_team_stats(team_id, season="2023-24"):
-    """Get team stats"""
+def get_team_stats_bbr(team_name, season="2023-24"):
+    """
+    Scrapes team stats for a given team and season from Basketball-Reference.
+    Returns a DataFrame.
+    """
+    team_abbr = TEAM_NAME_TO_BBR_ABBR.get(team_name)
+    if not team_abbr:
+        st.error(f"Could not find abbreviation for team: {team_name}")
+        return pd.DataFrame()
+
+    bbr_season_year = BBR_SEASON_URL_MAP.get(season)
+    if not bbr_season_year:
+        st.warning(f"Invalid season format for Basketball-Reference: {season}")
+        return pd.DataFrame()
+
+    url = f"{BBR_BASE_URL}/teams/{team_abbr}/{bbr_season_year}.html"
+
     try:
-        team_dashboard = teamplayerdashboard.TeamPlayerDashboard(team_id=team_id, season=season)
-        return team_dashboard.get_data_frames()[1]  # Team stats
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'lxml')
+
+        # Team stats are usually in a table with id 'team_and_opponent' or similar
+        comment = soup.find(string=lambda text: isinstance(text, str) and 'id="team_and_opponent"' in text)
+        if comment:
+            soup_from_comment = BeautifulSoup(comment, 'lxml')
+            table = soup_from_comment.find('table', {'id': 'team_and_opponent'})
+        else:
+            table = soup.find('table', {'id': 'team_and_opponent'}) # Try direct find
+
+        if table:
+            df = pd.read_html(str(table))[0]
+            # Clean up column names
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = ['_'.join(col).strip() for col in df.columns.values]
+            else:
+                df.columns = [col.strip() for col in df.columns.values]
+
+            # Standardize column names
+            df = df.rename(columns={
+                'G': 'GP', 'MP': 'MIN', 'FG': 'FGM', 'FGA': 'FGA', 'FG%': 'FG_PCT',
+                '3P': 'FG3M', '3PA': 'FG3A', '3P%': 'FG3_PCT', 'FT': 'FTM', 'FTA': 'FTA', 'FT%': 'FT_PCT',
+                'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO', 'PF': 'PF', 'PTS': 'PTS'
+            })
+
+            if not df.empty:
+                # The 'team_and_opponent' table has two main rows: 'Team' and 'Opponent'.
+                # We want the 'Team' row.
+                team_stats_row = df[df['Rk'] == 'Team'].copy()
+                if team_stats_row.empty:
+                    # Fallback: if 'Rk' isn't 'Team', try the first row (common for overall team stats)
+                    team_stats_row = df.iloc[[0]].copy()
+
+                if not team_stats_row.empty:
+                    team_stats_row['TEAM_NAME'] = team_name
+                    team_stats_row['SEASON'] = season
+                    return team_stats_row
+                else:
+                    st.info(f"Could not extract team stats row for {team_name} in season {season}.")
+                    return pd.DataFrame()
+            else:
+                st.info(f"No stats found for team {team_name} in season {season} on Basketball-Reference.")
+                return pd.DataFrame()
+        else:
+            st.warning(f"Could not find team stats table for {team_name} on Basketball-Reference.")
+            return pd.DataFrame()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching team stats for {team_name} from Basketball-Reference: {e}")
+        return pd.DataFrame()
     except Exception as e:
-        st.error(f"Error fetching team stats: {str(e)}")
+        st.error(f"An unexpected error occurred while parsing team stats for {team_name}: {e}")
         return pd.DataFrame()
 
+# Redefine the main data fetching functions to use Basketball-Reference versions
+@st.cache_data(ttl=3600)
+def get_all_players():
+    """Get all NBA players (from BBR)."""
+    return get_all_players_bbr()
+
+@st.cache_data(ttl=3600)
+def get_all_teams():
+    """Get all NBA teams (from BBR)."""
+    return get_all_teams_bbr()
+
+@st.cache_data(ttl=300)
+def get_player_stats(player_name, season="2023-24"):
+    """Get player stats (from BBR)."""
+    return get_player_stats_bbr(player_name, season)
+
+@st.cache_data(ttl=300)
+def get_team_stats(team_name, season="2023-24"):
+    """Get team stats (from BBR)."""
+    return get_team_stats_bbr(team_name, season)
+
+
 def create_comparison_chart(data, players_names, metric):
     """Create comparison chart for players"""
     fig = go.Figure()
@@ -239,7 +448,7 @@ def player_comparison_page():
     st.markdown('<h2 class="section-header">Player vs Player Comparison</h2>', unsafe_allow_html=True)
 
     # Get all players
-    all_players = get_all_players()
+    all_players = get_all_players() # This now calls get_all_players_bbr()
     player_names = [player['full_name'] for player in all_players]
 
     col1, col2 = st.columns(2)
@@ -254,7 +463,7 @@ def player_comparison_page():
     with col2:
         seasons = st.multiselect(
             "Select Seasons",
-            ["2023-24", "2022-23", "2021-22", "2020-21", "2019-20"],
+            list(BBR_SEASON_URL_MAP.keys()), # Use keys from the BBR season map
             default=["2023-24"]
         )
 
@@ -264,13 +473,6 @@ def player_comparison_page():
             st.warning("Please select at least one player to compare.")
             return
 
-        # Get player IDs
-        player_ids = []
-        for name in selected_players:
-            player_id = next((p['id'] for p in all_players if p['full_name'] == name), None)
-            if player_id:
-                player_ids.append(player_id)
-
         # Fetch and display stats
         stats_tabs = st.tabs(["Basic Stats", "Advanced Stats", "Visualizations"])
 
@@ -278,19 +480,20 @@ def player_comparison_page():
             st.subheader("Basic Statistics")
             basic_stats_data = []
 
-            for i, player_id in enumerate(player_ids):
-                stats_df = get_player_stats(player_id)
-                if not stats_df.empty:
-                    # Filter by selected seasons
-                    filtered_stats = stats_df[stats_df['SEASON_ID'].isin(seasons)]
-                    if not filtered_stats.empty:
-                        avg_stats = filtered_stats.mean(numeric_only=True)
-                        avg_stats['PLAYER_NAME'] = selected_players[i]
-                        basic_stats_data.append(avg_stats)
+            for player_name in selected_players: # Iterate by name directly
+                for season in seasons:
+                    stats_df = get_player_stats(player_name, season) # Pass name and season
+                    if not stats_df.empty:
+                        # BBR returns one row per season, so no need to mean()
+                        # Ensure numeric columns are actually numeric
+                        for col in ['GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']:
+                            if col in stats_df.columns:
+                                stats_df[col] = pd.to_numeric(stats_df[col], errors='coerce')
+                        basic_stats_data.append(stats_df.iloc[0].to_dict()) # Take the first (and only) row
 
             if basic_stats_data:
                 comparison_df = pd.DataFrame(basic_stats_data)
-                basic_cols = ['PLAYER_NAME', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
+                basic_cols = ['PLAYER_NAME', 'SEASON_ID', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
                 display_cols = [col for col in basic_cols if col in comparison_df.columns]
                 st.dataframe(comparison_df[display_cols].round(2), use_container_width=True)
             else:
@@ -299,15 +502,20 @@ def player_comparison_page():
         with stats_tabs[1]:
             st.subheader("Advanced Statistics")
             if basic_stats_data:
-                advanced_df = comparison_df.copy()
+                advanced_df = pd.DataFrame(basic_stats_data).copy()
+                # Ensure numeric columns for calculations
+                for col in ['PTS', 'FGA', 'FTA']:
+                    if col in advanced_df.columns:
+                        advanced_df[col] = pd.to_numeric(advanced_df[col], errors='coerce')
+
                 # Calculate TS% (True Shooting Percentage)
                 if all(col in advanced_df.columns for col in ['PTS', 'FGA', 'FTA']):
-                    advanced_df['TS%'] = advanced_df.apply(
+                    advanced_df['TS_PCT'] = advanced_df.apply(
                         lambda row: row['PTS'] / (2 * (row['FGA'] + 0.44 * row['FTA'])) if (row['FGA'] + 0.44 * row['FTA']) != 0 else 0,
                         axis=1
                     )
 
-                advanced_cols = ['PLAYER_NAME', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS%'] if 'TS%' in advanced_df.columns else ['PLAYER_NAME', 'PTS', 'REB', 'AST', 'FG_PCT']
+                advanced_cols = ['PLAYER_NAME', 'SEASON_ID', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT'] if 'TS_PCT' in advanced_df.columns else ['PLAYER_NAME', 'SEASON_ID', 'PTS', 'REB', 'AST', 'FG_PCT']
                 display_cols = [col for col in advanced_cols if col in advanced_df.columns]
                 st.dataframe(advanced_df[display_cols].round(3), use_container_width=True)
             else:
@@ -317,6 +525,7 @@ def player_comparison_page():
             st.subheader("Player Comparison Charts")
 
             if basic_stats_data:
+                comparison_df = pd.DataFrame(basic_stats_data)
                 metrics = ['PTS', 'REB', 'AST', 'FG_PCT']
                 available_metrics = [m for m in metrics if m in comparison_df.columns]
 
@@ -324,35 +533,53 @@ def player_comparison_page():
                     selected_metric = st.selectbox("Select Metric to Visualize", available_metrics)
 
                     if selected_metric:
-                        # Bar chart comparison
-                        fig = px.bar(
-                            comparison_df,
-                            x='PLAYER_NAME',
-                            y=selected_metric,
-                            title=f"{selected_metric} Comparison",
-                            color='PLAYER_NAME'
-                        )
+                        # Bar chart comparison (for average over selected seasons if multiple seasons selected)
+                        # Or for each season if only one player selected
+                        if len(selected_players) == 1 and len(seasons) > 1:
+                            # Show trend over seasons for one player
+                            fig = px.line(
+                                comparison_df[comparison_df['PLAYER_NAME'] == selected_players[0]],
+                                x='SEASON_ID',
+                                y=selected_metric,
+                                title=f"{selected_players[0]} - {selected_metric} Trend",
+                                markers=True
+                            )
+                        else:
+                            # Average over selected seasons for multiple players for bar chart
+                            avg_comparison_df = comparison_df.groupby('PLAYER_NAME')[available_metrics].mean().reset_index()
+                            fig = px.bar(
+                                avg_comparison_df,
+                                x='PLAYER_NAME',
+                                y=selected_metric,
+                                title=f"Average {selected_metric} Comparison (Selected Seasons)",
+                                color='PLAYER_NAME'
+                            )
                         st.plotly_chart(fig, use_container_width=True)
 
                         # Radar chart for multi-metric comparison
-                        # It's crucial to normalize data for radar charts if metrics have vastly different scales.
                         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.columns]
 
                         if len(radar_metrics_for_chart) >= 3:
                             radar_data = {}
-                            scaled_comparison_df = comparison_df.copy()
+                            # Use the averaged data for radar chart if multiple seasons
+                            if len(seasons) > 1:
+                                radar_source_df = comparison_df.groupby('PLAYER_NAME')[radar_metrics_for_chart].mean().reset_index()
+                            else:
+                                radar_source_df = comparison_df.copy()
+
+                            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_comparison_df[col].min()
-                                max_val = scaled_comparison_df[col].max()
+                                min_val = scaled_radar_df[col].min()
+                                max_val = scaled_radar_df[col].max()
                                 if max_val > min_val:
-                                    scaled_comparison_df[col] = ((scaled_comparison_df[col] - min_val) / (max_val - min_val)) * 100
+                                    scaled_radar_df[col] = ((scaled_radar_df[col] - min_val) / (max_val - min_val)) * 100
                                 else:
-                                    scaled_comparison_df[col] = 0 # Default if all values are the same
+                                    scaled_radar_df[col] = 0 # Default if all values are the same
 
-                            for _, row in scaled_comparison_df.iterrows():
+                            for _, row in scaled_radar_df.iterrows():
                                 radar_data[row['PLAYER_NAME']] = {
                                     metric: row[metric] for metric in radar_metrics_for_chart
                                 }
@@ -373,7 +600,7 @@ def player_comparison_page():
 def team_comparison_page():
     st.markdown('<h2 class="section-header">Team vs Team Analysis</h2>', unsafe_allow_html=True)
 
-    all_teams = get_all_teams()
+    all_teams = get_all_teams() # This now calls get_all_teams_bbr()
     team_names = [team['full_name'] for team in all_teams]
 
     col1, col2 = st.columns(2)
@@ -388,7 +615,7 @@ def team_comparison_page():
     with col2:
         seasons = st.multiselect(
             "Select Seasons",
-            ["2023-24", "2022-23", "2021-22", "2020-21"],
+            list(BBR_SEASON_URL_MAP.keys()), # Use keys from the BBR season map
             default=["2023-24"]
         )
 
@@ -401,15 +628,14 @@ def team_comparison_page():
         team_stats_data = []
 
         for team_name in selected_teams:
-            team_id = next((t['id'] for t in all_teams if t['full_name'] == team_name), None)
-            if team_id:
-                for season in seasons:
-                    stats_df = get_team_stats(team_id, season)
-                    if not stats_df.empty:
-                        team_avg = stats_df.mean(numeric_only=True)
-                        team_avg['TEAM_NAME'] = team_name
-                        team_avg['SEASON'] = season
-                        team_stats_data.append(team_avg)
+            for season in seasons:
+                stats_df = get_team_stats(team_name, season) # Pass name and season
+                if not stats_df.empty:
+                    # Ensure numeric columns are actually numeric
+                    for col in ['PTS', 'REB', 'AST', 'FG_PCT', 'FG3_PCT', 'FT_PCT']:
+                        if col in stats_df.columns:
+                            stats_df[col] = pd.to_numeric(stats_df[col], errors='coerce')
+                    team_stats_data.append(stats_df.iloc[0].to_dict()) # Take the first (and only) row
 
         if team_stats_data:
             team_df = pd.DataFrame(team_stats_data)