Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,410 @@
+
 import streamlit as st
-import requests
 import pandas as pd
+import numpy as np
+import requests
+import json
+from datetime import datetime
+import io
 
-st.title("WNBA Player Overview - RapidAPI")
+# Try to import plotly, but make it optional
+try:
+    import plotly.express as px
+    import plotly.graph_objects as go
+    PLOTLY_AVAILABLE = True
+except ImportError:
+    PLOTLY_AVAILABLE = False
 
-player_id = st.text_input("Enter Player ID", "4433403")
+# Page configuration - MUST be first Streamlit command
+st.set_page_config(
+    page_title="WNBA Dashboard",
+    page_icon="🏀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
-if st.button("Fetch Player Overview"):
-    st.info("Fetching data, please wait...")
+# Show plotly warning after page config
+if not PLOTLY_AVAILABLE:
+    st.warning("Plotly not available. Some visualizations will be disabled.")
 
-    url = f"https://wnba-api.p.rapidapi.com/player-overview?playerId={player_id}"
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        color: #FF6B6B;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-card {
+        background-color: #F0F2F6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 5px solid #FF6B6B;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def fetch_wnba_player_gamelogs(season="2025", season_type="Regular Season"):
+    """
+    Fetch WNBA player game logs from the official WNBA stats API
+    """
+    url = "https://stats.wnba.com/stats/playergamelogs"
 
     headers = {
-        "x-rapidapi-key": "1ac1586d40msh8f06d59fafd1b99p180008jsn0ed93153e2d7",
-        "x-rapidapi-host": "wnba-api.p.rapidapi.com"
+        'Accept': 'application/json, text/plain, */*',
+        'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Referer': 'https://stats.wnba.com/players/boxscores-traditional/',
+        'Sec-Ch-Ua': '"Google Chrome";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
+        'Sec-Ch-Ua-Mobile': '?0',
+        'Sec-Ch-Ua-Platform': '"Windows"',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
+        'X-Nba-Stats-Origin': 'stats',
+        'X-Nba-Stats-Token': 'true'
     }
 
-    try:
-        response = requests.get(url, headers=headers, timeout=15)
+    params = {
+        'DateFrom': '',
+        'DateTo': '',
+        'GameSegment': '',
+        'LastNGames': '0',
+        'LeagueID': '10',  # WNBA League ID
+        'Location': '',
+        'MeasureType': 'Base',
+        'Month': '0',
+        'OpponentTeamID': '0',
+        'Outcome': '',
+        'PORound': '0',
+        'PaceAdjust': 'N',
+        'PerMode': 'Totals',
+        'Period': '0',
+        'PlusMinus': 'N',
+        'Rank': 'N',
+        'Season': season,
+        'SeasonSegment': '',
+        'SeasonType': season_type,
+        'ShotClockRange': '',
+        'VsConference': '',
+        'VsDivision': ''
+    }
 
-        if response.status_code == 200:
-            data = response.json()
-            st.success("Data fetched successfully!")
+    try:
+        response = requests.get(url, headers=headers, params=params, timeout=30)
+        response.raise_for_status()
 
-            st.json(data)  # Show raw JSON
+        data = response.json()
 
-            if isinstance(data, dict):
-                df = pd.json_normalize(data)
-                st.dataframe(df)
+        # Extract the data from the API response
+        if 'resultSets' in data and len(data['resultSets']) > 0:
+            result_set = data['resultSets'][0]
+            headers_list = result_set['headers']
+            rows = result_set['rowSet']
 
-                csv = df.to_csv(index=False).encode("utf-8")
-                st.download_button("Download CSV", csv, "player_overview.csv", "text/csv")
-            else:
-                st.warning("Unexpected response structure.")
+            # Create DataFrame
+            df = pd.DataFrame(rows, columns=headers_list)
+            return df, None
         else:
-            st.error(f"Request failed with status code: {response.status_code}")
+            return None, "No data found in API response"
 
+    except requests.exceptions.RequestException as e:
+        return None, f"API request failed: {str(e)}"
+    except json.JSONDecodeError as e:
+        return None, f"Failed to parse JSON response: {str(e)}"
     except Exception as e:
-        st.error(f"Error: {e}")
+        return None, f"Unexpected error: {str(e)}"
+
+def convert_df_to_excel(df):
+    """
+    Convert DataFrame to Excel format and return as bytes
+    """
+    output = io.BytesIO()
+    try:
+        with pd.ExcelWriter(output, engine='openpyxl') as writer:
+            df.to_excel(writer, index=False, sheet_name='WNBA_Player_GameLogs')
+    except ImportError:
+        # Fallback to xlsxwriter if openpyxl is not available
+        try:
+            with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                df.to_excel(writer, index=False, sheet_name='WNBA_Player_GameLogs')
+        except ImportError:
+            # If both fail, return CSV data with Excel extension
+            st.warning("Excel libraries not available. Downloading as CSV format instead.")
+            return df.to_csv(index=False).encode('utf-8')
+
+    output.seek(0)
+    return output.getvalue()
+
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">🏀 WNBA Dashboard</h1>', unsafe_allow_html=True)
+
+    # Sidebar
+    st.sidebar.title("Navigation")
+    page = st.sidebar.selectbox("Choose a page", ["Home", "WNBA API Data", "Data Analysis", "Visualizations", "Settings"])
+
+    if page == "Home":
+        show_home_page()
+    elif page == "WNBA API Data":
+        show_wnba_api_data()
+    elif page == "Data Analysis":
+        show_data_analysis()
+    elif page == "Visualizations":
+        show_visualizations()
+    elif page == "Settings":
+        show_settings()
+
+def show_home_page():
+    st.header("Welcome to the WNBA Dashboard")
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+        st.metric("Total Teams", "12", "0")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    with col2:
+        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+        st.metric("Season Games", "204", "+12")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    with col3:
+        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+        st.metric("Active Players", "144", "+5")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    st.markdown("---")
+
+    # Sample data display
+    st.subheader("Recent Games")
+    sample_data = pd.DataFrame({
+        'Date': ['2024-07-01', '2024-07-02', '2024-07-03'],
+        'Home Team': ['Las Vegas Aces', 'New York Liberty', 'Connecticut Sun'],
+        'Away Team': ['Seattle Storm', 'Chicago Sky', 'Indiana Fever'],
+        'Score': ['89-76', '92-85', '78-71']
+    })
+    st.dataframe(sample_data, use_container_width=True)
+
+def show_wnba_api_data():
+    st.header("🏀 WNBA Official API Data")
+    st.write("Fetch real-time player game logs from the official WNBA Stats API")
+
+    # API Configuration
+    col1, col2 = st.columns(2)
+
+    with col1:
+        season = st.selectbox(
+            "Select Season",
+            ["2025", "2024", "2023", "2022", "2021"],
+            index=0
+        )
+
+    with col2:
+        season_type = st.selectbox(
+            "Season Type",
+            ["Regular Season", "Playoffs", "Pre Season"],
+            index=0
+        )
+
+    # Fetch Data Button
+    if st.button("🔄 Fetch WNBA Player Game Logs", type="primary"):
+        with st.spinner("Fetching data from WNBA API..."):
+            df, error = fetch_wnba_player_gamelogs(season, season_type)
+
+            if error:
+                st.error(f"❌ Error fetching data: {error}")
+                st.info("💡 Try again in a few moments. The API might be temporarily unavailable.")
+            else:
+                st.success(f"✅ Successfully fetched {len(df)} player game logs!")
+
+                # Store data in session state
+                st.session_state['wnba_data'] = df
+                st.session_state['fetch_timestamp'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    # Display data if available
+    if 'wnba_data' in st.session_state:
+        df = st.session_state['wnba_data']
+        timestamp = st.session_state.get('fetch_timestamp', 'Unknown')
+
+        st.markdown(f"**Data fetched at:** {timestamp}")
+        st.markdown(f"**Total records:** {len(df)}")
+
+        # Data preview
+        st.subheader("📊 Data Preview")
+        st.dataframe(df.head(10), use_container_width=True)
+
+        # Data summary
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.subheader("📈 Quick Stats")
+            if 'PTS' in df.columns:
+                avg_points = df['PTS'].mean()
+                max_points = df['PTS'].max()
+                st.metric("Average Points", f"{avg_points:.1f}")
+                st.metric("Highest Points", f"{max_points}")
+
+            if 'PLAYER_NAME' in df.columns:
+                unique_players = df['PLAYER_NAME'].nunique()
+                st.metric("Unique Players", unique_players)
+
+        with col2:
+            st.subheader("🏆 Top Performers")
+            if 'PTS' in df.columns and 'PLAYER_NAME' in df.columns:
+                top_scorers = df.nlargest(5, 'PTS')[['PLAYER_NAME', 'PTS', 'GAME_DATE']]
+                st.dataframe(top_scorers, use_container_width=True)
+
+        # Export options
+        st.subheader("💾 Export Data")
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            # Excel download
+            excel_data = convert_df_to_excel(df)
+            st.download_button(
+                label="📊 Download as Excel",
+                data=excel_data,
+                file_name=f"wnba_player_gamelogs_{season}_{season_type.replace(' ', '_')}.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
+
+        with col2:
+            # CSV download
+            csv_data = df.to_csv(index=False)
+            st.download_button(
+                label="📄 Download as CSV",
+                data=csv_data,
+                file_name=f"wnba_player_gamelogs_{season}_{season_type.replace(' ', '_')}.csv",
+                mime="text/csv"
+            )
+
+        with col3:
+            # JSON download
+            json_data = df.to_json(orient='records', indent=2)
+            st.download_button(
+                label="🔗 Download as JSON",
+                data=json_data,
+                file_name=f"wnba_player_gamelogs_{season}_{season_type.replace(' ', '_')}.json",
+                mime="application/json"
+            )
+
+        # Advanced filtering
+        with st.expander("🔍 Advanced Filtering"):
+            if 'PLAYER_NAME' in df.columns:
+                selected_players = st.multiselect(
+                    "Filter by Players",
+                    options=sorted(df['PLAYER_NAME'].unique()),
+                    default=[]
+                )
+
+                if selected_players:
+                    filtered_df = df[df['PLAYER_NAME'].isin(selected_players)]
+                    st.write(f"Filtered data: {len(filtered_df)} records")
+                    st.dataframe(filtered_df, use_container_width=True)
+
+    else:
+        st.info("👆 Click the button above to fetch WNBA player game logs data")
+
+        # API Information
+        st.subheader("ℹ️ About the WNBA Stats API")
+        st.write("""
+        This tool fetches real-time data from the official WNBA Stats API, including:
+
+        - **Player Game Logs**: Individual player performance in each game
+        - **Season Data**: Regular season, playoffs, and preseason statistics
+        - **Comprehensive Stats**: Points, rebounds, assists, shooting percentages, and more
+        - **Export Options**: Download data in Excel, CSV, or JSON format
+
+        The data is fetched directly from `stats.wnba.com` and includes all official WNBA statistics.
+        """)
+
+def show_data_analysis():
+    st.header("Data Analysis")
+
+    # File uploader
+    uploaded_file = st.file_uploader("Upload your WNBA data", type=['csv', 'xlsx'])
+
+    if uploaded_file is not None:
+        try:
+            if uploaded_file.name.endswith('.csv'):
+                df = pd.read_csv(uploaded_file)
+            else:
+                df = pd.read_excel(uploaded_file)
+
+            st.success("Data uploaded successfully!")
+            st.dataframe(df.head(), use_container_width=True)
+
+            # Basic statistics
+            st.subheader("Data Summary")
+            st.write(df.describe())
+
+        except Exception as e:
+            st.error(f"Error loading data: {str(e)}")
+    else:
+        st.info("Please upload a CSV or Excel file to begin analysis.")
+
+def show_visualizations():
+    st.header("Data Visualizations")
+
+    if PLOTLY_AVAILABLE:
+        # Sample visualization
+        st.subheader("Sample Team Performance Chart")
+
+        # Generate sample data
+        teams = ['Las Vegas Aces', 'New York Liberty', 'Connecticut Sun', 'Seattle Storm', 'Chicago Sky']
+        wins = np.random.randint(15, 25, len(teams))
+        losses = np.random.randint(5, 15, len(teams))
+
+        fig = px.bar(
+            x=teams,
+            y=[wins, losses],
+            title="Team Wins vs Losses",
+            labels={'x': 'Teams', 'y': 'Games'},
+            color_discrete_sequence=['#FF6B6B', '#4ECDC4']
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+    else:
+        st.info("Advanced visualizations require plotly. Using basic charts instead.")
+
+    # Interactive chart (using Streamlit's built-in charts)
+    st.subheader("Interactive Player Stats")
+    chart_type = st.selectbox("Select chart type", ["Bar Chart", "Line Chart", "Area Chart"])
+
+    # Sample data
+    chart_data = pd.DataFrame({
+        'Points': np.random.randint(10, 30, 10),
+        'Rebounds': np.random.randint(5, 15, 10),
+        'Assists': np.random.randint(2, 12, 10)
+    })
+
+    if chart_type == "Bar Chart":
+        st.bar_chart(chart_data)
+    elif chart_type == "Line Chart":
+        st.line_chart(chart_data)
+    elif chart_type == "Area Chart":
+        st.area_chart(chart_data)
+
+def show_settings():
+    st.header("Settings")
+
+    st.subheader("Display Preferences")
+    theme = st.selectbox("Choose theme", ["Light", "Dark"])
+    show_sidebar = st.checkbox("Show sidebar by default", value=True)
+
+    st.subheader("Data Preferences")
+    auto_refresh = st.checkbox("Auto-refresh data")
+    refresh_interval = st.slider("Refresh interval (minutes)", 1, 60, 5)
+
+    st.subheader("Export Settings")
+    export_format = st.selectbox("Default export format", ["CSV", "Excel", "JSON"])
+
+    if st.button("Save Settings"):
+        st.success("Settings saved successfully!")
+
+if __name__ == "__main__":
+    main()