Update src/streamlit_app.py

src/streamlit_app.py

@@ -6,7 +6,7 @@ import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import requests
 from nba_api.stats.endpoints import (
-    playercareerstats, playercompare, teamdetails, teamgamelog,
+    playercareerstats, teamdetails, teamgamelog,
     leaguegamelog, playergamelog, commonplayerinfo, teamplayerdashboard,
     leagueleaders, playerestimatedmetrics, teamestimatedmetrics
 )
@@ -15,6 +15,25 @@ import time
 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
 st.set_page_config(
     page_title="NBA Analytics Hub",
@@ -54,31 +73,49 @@ if 'chat_history' not in st.session_state:
 
 # Perplexity API configuration
 PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_API_KEY")
+PERPLEXITY_API_URL = "https://api.perplexity.ai/chat/completions"
+
+# ---------- 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):
+    """
+    Queries the Perplexity AI API with a given prompt and system message.
+    """
+    if not api_key:
+        st.error("Perplexity API Key is not set. Please configure it as an environment variable (PERPLEXITY_API_KEY).")
+        return None
 
-def query_perplexity(prompt, max_tokens=500):
-    """Query Perplexity Sonar API"""
-    if not PERPLEXITY_API_KEY:
-        return "Please configure your Perplexity API key in Streamlit secrets."
-    
-    url = "https://api.perplexity.ai/chat/completions"
     headers = {
-        "Authorization": f"Bearer {PERPLEXITY_API_KEY}",
-        "Content-Type": "application/json"
+        'Authorization': f'Bearer {api_key}',
+        'Content-Type': 'application/json'
     }
-    
-    data = {
-        "model": "sonar-medium-online",
-        "messages": [{"role": "user", "content": prompt}],
+    payload = {
+        'model': 'sonar-medium-online', # Or 'sonar-pro-online' for more advanced capabilities
+        'messages': [
+            {'role': 'system', 'content': system_message},
+            {'role': 'user', 'content': prompt}
+        ],
         "max_tokens": max_tokens,
-        "temperature": 0.2
+        "temperature": temperature
     }
-    
     try:
-        response = requests.post(url, json=data, headers=headers)
-        response.raise_for_status()
-        return response.json()["choices"][0]["message"]["content"]
+        with st.spinner("Querying Perplexity AI..."):
+            response = requests.post(PERPLEXITY_API_URL, headers=headers, json=payload, timeout=45)
+            response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+        data = response.json()
+        return data.get('choices', [{}])[0].get('message', {}).get('content', '')
+    except requests.exceptions.RequestException as e:
+        error_message = f"Error communicating with Perplexity API: {e}"
+        if e.response is not None:
+            try:
+                error_detail = e.response.json().get("error", {}).get("message", e.response.text)
+                error_message = f"Perplexity API error: {error_detail}"
+            except ValueError: # If response is not valid JSON
+                error_message = f"Perplexity API error: {e.response.status_code} - {e.response.reason}"
+        st.error(error_message)
+        return None
     except Exception as e:
-        return f"Error querying Perplexity API: {str(e)}"
+        st.error(f"An unexpected error occurred with Perplexity API: {e}")
+        return None
 
 @st.cache_data(ttl=3600)
 def get_all_players():
@@ -113,7 +150,7 @@ def get_team_stats(team_id, season="2023-24"):
 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_NAME'].values:
             player_data = data[data['PLAYER_NAME'] == player]
@@ -124,7 +161,7 @@ def create_comparison_chart(data, players_names, metric):
                 name=player,
                 line=dict(width=3)
             ))
-    
+
     fig.update_layout(
         title=f"{metric} Comparison",
         xaxis_title="Season",
@@ -132,38 +169,42 @@ def create_comparison_chart(data, players_names, metric):
         hovermode='x unified',
         height=500
     )
-    
+
     return fig
 
 def create_radar_chart(player_stats, categories):
     """Create radar chart for player comparison"""
     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(
-            r=[stats.get(cat, 0) for cat in categories],
+            r=r_values,
             theta=categories,
             fill='toself',
             name=player_name,
             opacity=0.7
         ))
-    
+
     fig.update_layout(
         polar=dict(
             radialaxis=dict(
                 visible=True,
+                # The range should be adjusted based on the scaled data (0-100)
                 range=[0, 100]
             )),
         showlegend=True,
         title="Player Comparison Radar Chart"
     )
-    
+
     return fig
 
 # Main app
 def main():
     st.markdown('<h1 class="main-header">🏀 NBA Analytics Hub</h1>', unsafe_allow_html=True)
-    
+
     # Sidebar navigation
     st.sidebar.title("Navigation")
     page = st.sidebar.selectbox(
@@ -178,7 +219,7 @@ def main():
             "Roster Builder"
         ]
     )
-    
+
     if page == "Player vs Player Comparison":
         player_comparison_page()
     elif page == "Team vs Team Analysis":
@@ -196,42 +237,47 @@ def main():
 
 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()
     player_names = [player['full_name'] for player in all_players]
-    
+
     col1, col2 = st.columns(2)
-    
+
     with col1:
         selected_players = st.multiselect(
             "Select Players to Compare (up to 4)",
             player_names,
             max_selections=4
         )
-    
+
     with col2:
         seasons = st.multiselect(
             "Select Seasons",
             ["2023-24", "2022-23", "2021-22", "2020-21", "2019-20"],
             default=["2023-24"]
         )
-    
-    if selected_players:
+
+    # Add a button to trigger the comparison
+    if st.button("Run Player Comparison"):
+        if not selected_players:
+            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"])
-        
+
         with stats_tabs[0]:
             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:
@@ -241,84 +287,119 @@ def player_comparison_page():
                         avg_stats = filtered_stats.mean(numeric_only=True)
                         avg_stats['PLAYER_NAME'] = selected_players[i]
                         basic_stats_data.append(avg_stats)
-            
+
             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']
                 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:
+                st.info("No data available for the selected players and seasons.")
+
         with stats_tabs[1]:
             st.subheader("Advanced Statistics")
-            # Display advanced metrics like PER, TS%, etc.
             if basic_stats_data:
                 advanced_df = comparison_df.copy()
-                # Calculate some advanced stats
+                # Calculate TS% (True Shooting Percentage)
                 if all(col in advanced_df.columns for col in ['PTS', 'FGA', 'FTA']):
-                    advanced_df['TS%'] = advanced_df['PTS'] / (2 * (advanced_df['FGA'] + 0.44 * advanced_df['FTA']))
-                
+                    advanced_df['TS%'] = 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']
                 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:
+                st.info("No data available for advanced statistics.")
+
         with stats_tabs[2]:
             st.subheader("Player Comparison Charts")
-            
+
             if basic_stats_data:
-                # Create comparison charts
                 metrics = ['PTS', 'REB', 'AST', 'FG_PCT']
                 available_metrics = [m for m in metrics if m in comparison_df.columns]
-                
-                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'
-                    )
-                    st.plotly_chart(fig, use_container_width=True)
-                    
-                    # Radar chart for multi-metric comparison
-                    if len(available_metrics) >= 3:
-                        radar_data = {}
-                        for _, row in comparison_df.iterrows():
-                            radar_data[row['PLAYER_NAME']] = {
-                                metric: row[metric] for metric in available_metrics[:5]
-                            }
-                        
-                        if radar_data:
-                            radar_fig = create_radar_chart(radar_data, available_metrics[:5])
-                            st.plotly_chart(radar_fig, use_container_width=True)
+
+                if available_metrics:
+                    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'
+                        )
+                        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()
+
+                            # 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()
+                                if max_val > min_val:
+                                    scaled_comparison_df[col] = ((scaled_comparison_df[col] - min_val) / (max_val - min_val)) * 100
+                                else:
+                                    scaled_comparison_df[col] = 0 # Default if all values are the same
+
+                            for _, row in scaled_comparison_df.iterrows():
+                                radar_data[row['PLAYER_NAME']] = {
+                                    metric: row[metric] for metric in radar_metrics_for_chart
+                                }
+
+                            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_comparison_page():
     st.markdown('<h2 class="section-header">Team vs Team Analysis</h2>', unsafe_allow_html=True)
-    
+
     all_teams = get_all_teams()
     team_names = [team['full_name'] for team in all_teams]
-    
+
     col1, col2 = st.columns(2)
-    
+
     with col1:
         selected_teams = st.multiselect(
             "Select Teams to Compare",
             team_names,
             max_selections=4
         )
-    
+
     with col2:
         seasons = st.multiselect(
             "Select Seasons",
             ["2023-24", "2022-23", "2021-22", "2020-21"],
             default=["2023-24"]
         )
-    
-    if selected_teams:
+
+    # Add a button to trigger the comparison
+    if st.button("Run Team Comparison"):
+        if not selected_teams:
+            st.warning("Please select at least one team to compare.")
+            return
+
         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:
@@ -329,24 +410,24 @@ def team_comparison_page():
                         team_avg['TEAM_NAME'] = team_name
                         team_avg['SEASON'] = season
                         team_stats_data.append(team_avg)
-        
+
         if team_stats_data:
             team_df = pd.DataFrame(team_stats_data)
-            
+
             # Display team comparison
             st.subheader("Team Statistics Comparison")
             team_cols = ['TEAM_NAME', 'SEASON', 'PTS', 'REB', 'AST', 'FG_PCT', 'FG3_PCT', 'FT_PCT']
             display_cols = [col for col in team_cols if col in team_df.columns]
             st.dataframe(team_df[display_cols].round(2), use_container_width=True)
-            
+
             # Visualization
             st.subheader("Team Performance Visualization")
             metric_options = ['PTS', 'REB', 'AST', 'FG_PCT']
             available_metrics = [m for m in metric_options if m in team_df.columns]
-            
+
             if available_metrics:
                 selected_metric = st.selectbox("Select Metric", available_metrics)
-                
+
                 fig = px.bar(
                     team_df,
                     x='TEAM_NAME',
@@ -356,18 +437,24 @@ def team_comparison_page():
                     barmode='group'
                 )
                 st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("No common metrics available for visualization.")
+        else:
+            st.info("No data available for the selected teams and seasons.")
+
 
 def awards_predictor_page():
     st.markdown('<h2 class="section-header">NBA Awards Predictor</h2>', unsafe_allow_html=True)
-    
+
     award_type = st.selectbox(
         "Select Award Type",
         ["MVP", "Defensive Player of the Year", "Rookie of the Year", "6th Man of the Year", "All-NBA First Team"]
     )
-    
+
     st.subheader(f"{award_type} Prediction Criteria")
-    
+
     # Define criteria for different awards
+    criteria = {}
     if award_type == "MVP":
         criteria = {
             "Points Per Game": st.slider("Minimum PPG", 15.0, 35.0, 25.0),
@@ -382,150 +469,154 @@ def awards_predictor_page():
             "Defensive Rating": st.slider("Maximum Defensive Rating", 90.0, 120.0, 105.0),
             "Team Defensive Ranking": st.slider("Maximum Team Def Rank", 1, 30, 10)
         }
-    else:
+    else: # Default for Rookie of the Year, 6th Man, All-NBA
         criteria = {
             "Points Per Game": st.slider("Minimum PPG", 10.0, 30.0, 15.0),
             "Games Played": st.slider("Minimum Games", 50, 82, 65),
             "Shooting Efficiency": st.slider("Minimum FG%", 0.35, 0.65, 0.45)
         }
-    
+
     if st.button("Generate Predictions"):
-        # Use AI to analyze and predict
         prompt = f"""
         Based on the following criteria for {award_type}, analyze current NBA players and provide predictions:
-        
+
         Criteria: {criteria}
-        
+
         Please provide:
         1. Top 5 candidates with their stats
         2. Analysis of why each candidate fits the criteria
         3. Your prediction for the winner with reasoning
-        
+
         Focus on current 2023-24 season performance and recent trends.
         """
-        
-        with st.spinner("Analyzing candidates..."):
-            prediction = query_perplexity(prompt, max_tokens=800)
+
+        prediction = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=800, system_message="You are an NBA awards prediction expert AI.")
+        if prediction:
             st.markdown("### AI Prediction Analysis")
             st.write(prediction)
 
 def ai_chat_page():
     st.markdown('<h2 class="section-header">AI NBA Chat & Insights</h2>', unsafe_allow_html=True)
-    
+
     # Chat interface
     st.subheader("Ask AI About NBA Stats and Insights")
-    
+
     # Display chat history
     for message in st.session_state.chat_history:
         with st.chat_message(message["role"]):
             st.write(message["content"])
-    
+
     # Chat input
     if prompt := st.chat_input("Ask about NBA players, teams, stats, or strategies..."):
         # Add user message to chat history
         st.session_state.chat_history.append({"role": "user", "content": prompt})
-        
+
         # Display user message
         with st.chat_message("user"):
             st.write(prompt)
-        
+
         # Generate AI response
         with st.chat_message("assistant"):
-            with st.spinner("Thinking..."):
-                # Enhance prompt with NBA context
-                enhanced_prompt = f"""
-                As an NBA expert analyst, please answer this question about basketball:
-                
-                {prompt}
-                
-                Please provide detailed analysis with current stats, trends, and insights when relevant.
-                If specific player or team stats are mentioned, include recent performance data.
-                """
-                
-                response = query_perplexity(enhanced_prompt, max_tokens=700)
+            # Enhance prompt with NBA context
+            enhanced_prompt = f"""
+            As an NBA expert analyst, please answer this question about basketball:
+
+            {prompt}
+
+            Please provide detailed analysis with current stats, trends, and insights when relevant.
+            If specific player or team stats are mentioned, include recent performance data.
+            """
+
+            response = get_perplexity_response(PERPLEXITY_API_KEY, enhanced_prompt, max_tokens=700, system_message="You are an NBA expert analyst AI.")
+            if response:
                 st.write(response)
-                
                 # Add assistant response to chat history
                 st.session_state.chat_history.append({"role": "assistant", "content": response})
-    
+            else:
+                st.session_state.chat_history.append({"role": "assistant", "content": "Sorry, I couldn't get a response from the AI."})
+
+
     # Quick action buttons
     st.subheader("Quick Insights")
     col1, col2, col3 = st.columns(3)
-    
+
     with col1:
         if st.button("🏆 Championship Contenders"):
             prompt = "Analyze the current NBA championship contenders for 2024. Who are the top 5 teams and why?"
-            response = query_perplexity(prompt)
-            st.write(response)
-    
+            response = get_perplexity_response(PERPLEXITY_API_KEY, prompt, system_message="You are an NBA expert analyst AI.")
+            if response:
+                st.write(response)
+
     with col2:
         if st.button("⭐ Rising Stars"):
             prompt = "Who are the most promising young NBA players to watch in 2024? Focus on players 23 and under."
-            response = query_perplexity(prompt)
-            st.write(response)
-    
+            response = get_perplexity_response(PERPLEXITY_API_KEY, prompt, system_message="You are an NBA expert analyst AI.")
+            if response:
+                st.write(response)
+
     with col3:
         if st.button("📊 Trade Analysis"):
             prompt = "What are some potential NBA trades that could happen this season? Analyze team needs and available players."
-            response = query_perplexity(prompt)
-            st.write(response)
+            response = get_perplexity_response(PERPLEXITY_API_KEY, prompt, system_message="You are an NBA expert analyst AI.")
+            if response:
+                st.write(response)
 
 def young_player_projections_page():
     st.markdown('<h2 class="section-header">Young Player Projections</h2>', unsafe_allow_html=True)
-    
+
     # Player selection
     all_players = get_all_players()
     player_names = [player['full_name'] for player in all_players]
-    
+
     selected_player = st.selectbox("Select Young Player (or enter manually)", [""] + player_names)
-    
+
     if not selected_player:
         manual_player = st.text_input("Enter Player Name Manually")
         if manual_player:
             selected_player = manual_player
-    
+
     if selected_player:
         col1, col2 = st.columns(2)
-        
+
         with col1:
             current_age = st.number_input("Current Age", min_value=18, max_value=25, value=21)
             years_in_league = st.number_input("Years in NBA", min_value=0, max_value=7, value=2)
-        
+
         with col2:
             current_ppg = st.number_input("Current PPG", min_value=0.0, max_value=40.0, value=15.0)
             current_rpg = st.number_input("Current RPG", min_value=0.0, max_value=20.0, value=5.0)
             current_apg = st.number_input("Current APG", min_value=0.0, max_value=15.0, value=3.0)
-        
+
         if st.button("Generate AI Projection"):
             prompt = f"""
             Analyze and project the future potential of NBA player {selected_player}:
-            
+
             Current Stats:
             - Age: {current_age}
             - Years in NBA: {years_in_league}
             - PPG: {current_ppg}
             - RPG: {current_rpg}
             - APG: {current_apg}
-            
+
             Please provide:
             1. 3-year projection of their stats
             2. Peak potential analysis
             3. Areas for improvement
             4. Comparison to similar players at the same age
             5. Career trajectory prediction
-            
+
             Base your analysis on historical player development patterns and current NBA trends.
             """
-            
-            with st.spinner("Generating projection..."):
-                projection = query_perplexity(prompt, max_tokens=800)
+
+            projection = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=800, system_message="You are an NBA player projection expert AI.")
+            if projection:
                 st.markdown("### AI Player Projection")
                 st.write(projection)
-                
+
                 # Create a simple projection visualization
                 years = [f"Year {i+1}" for i in range(5)]
                 projected_ppg = [current_ppg * (1 + 0.1 * i) for i in range(5)]  # Simple growth model
-                
+
                 fig = go.Figure()
                 fig.add_trace(go.Scatter(
                     x=years,
@@ -534,162 +625,166 @@ def young_player_projections_page():
                     name='Projected PPG',
                     line=dict(width=3, color='blue')
                 ))
-                
+
                 fig.update_layout(
                     title=f"{selected_player} - PPG Projection",
                     xaxis_title="Years",
                     yaxis_title="Points Per Game",
                     height=400
                 )
-                
+
                 st.plotly_chart(fig, use_container_width=True)
 
 def similar_players_page():
     st.markdown('<h2 class="section-header">Find Similar Players</h2>', unsafe_allow_html=True)
-    
+
     all_players = get_all_players()
     player_names = [player['full_name'] for player in all_players]
-    
+
     target_player = st.selectbox("Select Target Player", player_names)
-    
+
     similarity_criteria = st.multiselect(
         "Select Similarity Criteria",
         ["Position", "Height/Weight", "Playing Style", "Statistical Profile", "Age/Experience"],
         default=["Playing Style", "Statistical Profile"]
     )
-    
+
     if target_player and similarity_criteria:
         if st.button("Find Similar Players"):
             prompt = f"""
             Find NBA players similar to {target_player} based on the following criteria:
             {', '.join(similarity_criteria)}
-            
+
             Please provide:
             1. Top 5 most similar current NBA players
             2. Top 3 historical comparisons
             3. Explanation of similarities for each player
             4. Key differences that distinguish them
             5. Playing style analysis
-            
+
             Focus on both statistical similarities and playing style/role similarities.
             """
-            
-            with st.spinner("Finding similar players..."):
-                similar_players = query_perplexity(prompt, max_tokens=800)
+
+            similar_players = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=800, system_message="You are an NBA player similarity expert AI.")
+            if similar_players:
                 st.markdown("### Similar Players Analysis")
                 st.write(similar_players)
-    
+
     # Alternative: Manual similarity finder
     st.subheader("Manual Player Comparison Tool")
-    
+
     col1, col2 = st.columns(2)
-    
+
     with col1:
         player1 = st.selectbox("Player 1", player_names, key="sim1")
-    
+
     with col2:
         player2 = st.selectbox("Player 2", player_names, key="sim2")
-    
+
     if player1 and player2 and player1 != player2:
         if st.button("Compare Players"):
             prompt = f"""
             Compare {player1} and {player2} in detail:
-            
+
             Please analyze:
             1. Statistical comparison (current season)
             2. Playing style similarities and differences
             3. Strengths and weaknesses of each
             4. Team impact and role
             5. Overall similarity score (1-10)
-            
+
             Provide a comprehensive comparison with specific examples.
             """
-            
-            comparison = query_perplexity(prompt, max_tokens=700)
-            st.markdown("### Player Comparison Analysis")
-            st.write(comparison)
+
+            comparison = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=700, system_message="You are an NBA player comparison expert AI.")
+            if comparison:
+                st.markdown("### Player Comparison Analysis")
+                st.write(comparison)
 
 def roster_builder_page():
     st.markdown('<h2 class="section-header">NBA Roster Builder</h2>', unsafe_allow_html=True)
-    
+
     st.subheader("Build Your Ideal NBA Roster")
-    
+
     # Roster building parameters
     col1, col2 = st.columns(2)
-    
+
     with col1:
         salary_cap = st.number_input("Salary Cap (Millions)", min_value=100, max_value=200, value=136)
         team_strategy = st.selectbox(
             "Team Strategy",
             ["Championship Contender", "Young Core Development", "Balanced Veteran Mix", "Small Ball", "Defense First"]
         )
-    
+
     with col2:
         key_positions = st.multiselect(
             "Priority Positions",
             ["Point Guard", "Shooting Guard", "Small Forward", "Power Forward", "Center"],
             default=["Point Guard", "Center"]
         )
-    
+
     # Player budget allocation
     st.subheader("Budget Allocation")
     position_budgets = {}
-    
+
     positions = ["PG", "SG", "SF", "PF", "C"]
     cols = st.columns(5)
-    
+
     total_allocated = 0
     for i, pos in enumerate(positions):
         with cols[i]:
             budget = st.number_input(f"{pos} Budget ($M)", min_value=0, max_value=50, value=20, key=f"budget_{pos}")
             position_budgets[pos] = budget
             total_allocated += budget
-    
+
     st.write(f"Total Allocated: ${total_allocated}M / ${salary_cap}M")
-    
+
     if total_allocated > salary_cap:
         st.error("Budget exceeds salary cap!")
-    
+
     # Generate roster suggestions
     if st.button("Generate Roster Suggestions"):
-        prompt = f"""
-        Build an NBA roster with the following constraints:
-        
-        - Salary Cap: ${salary_cap} million
-        - Team Strategy: {team_strategy}
-        - Priority Positions: {', '.join(key_positions)}
-        - Position Budgets: {position_budgets}
-        
-        Please provide:
-        1. Starting lineup with specific player recommendations
-        2. Key bench players (6th man, backup center, etc.)
-        3. Total estimated salary breakdown
-        4. Rationale for each major signing
-        5. How this roster fits the chosen strategy
-        6. Potential weaknesses and how to address them
-        
-        Focus on realistic player availability and current market values.
-        """
-        
-        with st.spinner("Building your roster..."):
-            roster_suggestions = query_perplexity(prompt, max_tokens=900)
-            st.markdown("### AI Roster Recommendations")
-            st.write(roster_suggestions)
-    
+        if total_allocated <= salary_cap:
+            prompt = f"""
+            Build an NBA roster with the following constraints:
+
+            - Salary Cap: ${salary_cap} million
+            - Team Strategy: {team_strategy}
+            - Priority Positions: {', '.join(key_positions)}
+            - Position Budgets: {position_budgets}
+
+            Please provide:
+            1. Starting lineup with specific player recommendations
+            2. Key bench players (6th man, backup center, etc.)
+            3. Total estimated salary breakdown
+            4. Rationale for each major signing
+            5. How this roster fits the chosen strategy
+            6. Potential weaknesses and how to address them
+
+            Focus on realistic player availability and current market values.
+            """
+
+            roster_suggestions = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=900, system_message="You are an NBA roster building expert AI.")
+            if roster_suggestions:
+                st.markdown("### AI Roster Recommendations")
+                st.write(roster_suggestions)
+        else:
+            st.warning("Please adjust your budget to be within the salary cap before generating suggestions.")
+
     # Trade scenario analyzer
     st.subheader("Trade Scenario Analyzer")
-    
+
     trade_team1 = st.text_input("Team 1 Trading:")
     trade_team2 = st.text_input("Team 2 Trading:")
-    
+
     if trade_team1 and trade_team2:
         if st.button("Analyze Trade"):
             prompt = f"""
             Analyze this potential NBA trade:
-            
+
             Team 1 trades: {trade_team1}
             Team 2 trades: {trade_team2}
-            
+
             Please evaluate:
             1. Fair value assessment
             2. How this trade helps each team
@@ -697,13 +792,14 @@ def roster_builder_page():
             4. Impact on team chemistry and performance
             5. Likelihood of this trade happening
             6. Alternative trade suggestions
-            
+
             Consider current team needs and player contracts.
             """
-            
-            trade_analysis = query_perplexity(prompt, max_tokens=700)
-            st.markdown("### Trade Analysis")
-            st.write(trade_analysis)
+
+            trade_analysis = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=700, system_message="You are an NBA trade analysis expert AI.")
+            if trade_analysis:
+                st.markdown("### Trade Analysis")
+                st.write(trade_analysis)
 
 if __name__ == "__main__":
     main()