app.py

import streamlit as st
import pandas as pd
import joblib
from sklearn.ensemble import RandomForestRegressor
import plotly.graph_objects as go
from PIL import Image
import plotly.express as px

# Set the page configuration
st.set_page_config(
    page_title="NBA Player Performance Predictor",
    page_icon="🏀",
    layout="centered"
)

# Mapping for position to numeric values
position_mapping = {
    "PG": 1.0,
    "SG": 2.0,
    "SF": 3.0,
    "PF": 4.0,
    "C": 5.0,
}

# Injury types and average days
injury_types = [
    "foot fracture injury", "hip flexor surgery injury", "calf strain injury",
    "quad injury injury", "shoulder sprain injury", "foot sprain injury",
    "torn rotator cuff injury injury", "torn mcl injury", "hip flexor strain injury",
    "fractured leg injury", "sprained mcl injury", "ankle sprain injury",
    "hamstring injury injury", "meniscus tear injury", "torn hamstring injury",
    "dislocated shoulder injury", "ankle fracture injury", "fractured hand injury",
    "bone spurs injury", "acl tear injury", "hip labrum injury", "back surgery injury",
    "arm injury injury", "torn shoulder labrum injury", "lower back spasm injury"
]

average_days_injured = {
    "foot fracture injury": 207.666667,
    "hip flexor surgery injury": 256.000000,
    "calf strain injury": 236.000000,
    "quad injury injury": 283.000000,
    "shoulder sprain injury": 259.500000,
    "foot sprain injury": 294.000000,
    "torn rotator cuff injury injury": 251.500000,
    "torn mcl injury": 271.000000,
    "hip flexor strain injury": 253.000000,
    "fractured leg injury": 250.250000,
    "sprained mcl injury": 228.666667,
    "ankle sprain injury": 231.333333,
    "hamstring injury injury": 220.000000,
    "meniscus tear injury": 201.250000,
    "torn hamstring injury": 187.666667,
    "dislocated shoulder injury": 269.000000,
    "ankle fracture injury": 114.500000,
    "fractured hand injury": 169.142857,
    "bone spurs injury": 151.500000,
    "acl tear injury": 268.000000,
    "hip labrum injury": 247.500000,
    "back surgery injury": 215.800000,
    "arm injury injury": 303.666667,
    "torn shoulder labrum injury": 195.666667,
    "lower back spasm injury": 234.000000,
}

team_logo_paths = {
    "Cleveland Cavaliers": "NBA_LOGOs/Clevelan-Cavaliers-logo-2022.png",
    "Atlanta Hawks": "NBA_LOGOs/nba-atlanta-hawks-logo.png",
    "Boston Celtics": "NBA_LOGOs/nba-boston-celtics-logo.png",
    "Brooklyn Nets": "NBA_LOGOs/nba-brooklyn-nets-logo.png",
    "Charlotte Hornets": "NBA_LOGOs/nba-charlotte-hornets-logo.png",
    "Chicago Bulls": "NBA_LOGOs/nba-chicago-bulls-logo.png",
    "Dallas Mavericks": "NBA_LOGOs/nba-dallas-mavericks-logo.png",
    "Denver Nuggets": "NBA_LOGOs/nba-denver-nuggets-logo-2018.png",
    "Detroit Pistons": "NBA_LOGOs/nba-detroit-pistons-logo.png",
    "Golden State Warriors": "NBA_LOGOs/nba-golden-state-warriors-logo-2020.png",
    "Houston Rockets": "NBA_LOGOs/nba-houston-rockets-logo-2020.png",
    "Indiana Pacers": "NBA_LOGOs/nba-indiana-pacers-logo.png",
    "LA Clippers": "NBA_LOGOs/nba-la-clippers-logo.png",
    "Los Angeles Lakers": "NBA_LOGOs/nba-los-angeles-lakers-logo.png",
    "Memphis Grizzlies": "NBA_LOGOs/nba-memphis-grizzlies-logo.png",
    "Miami Heat": "NBA_LOGOs/nba-miami-heat-logo.png",
    "Milwaukee Bucks": "NBA_LOGOs/nba-milwaukee-bucks-logo.png",
    "Minnesota Timberwolves": "NBA_LOGOs/nba-minnesota-timberwolves-logo.png",
    "New Orleans Pelicans": "NBA_LOGOs/nba-new-orleans-pelicans-logo.png",
    "New York Knicks": "NBA_LOGOs/nba-new-york-knicks-logo.png",
    "Oklahoma City Thunder": "NBA_LOGOs/nba-oklahoma-city-thunder-logo.png",
    "Orlando Magic": "NBA_LOGOs/nba-orlando-magic-logo.png",
    "Philadelphia 76ers": "NBA_LOGOs/nba-philadelphia-76ers-logo.png",
    "Phoenix Suns": "NBA_LOGOs/nba-phoenix-suns-logo.png",
    "Portland Trail Blazers": "NBA_LOGOs/nba-portland-trail-blazers-logo.png",
    "Sacramento Kings": "NBA_LOGOs/nba-sacramento-kings-logo.png",
    "San Antonio Spurs": "NBA_LOGOs/nba-san-antonio-spurs-logo.png",
    "Toronto Raptors": "NBA_LOGOs/nba-toronto-raptors-logo-2020.png",
    "Utah Jazz": "NBA_LOGOs/nba-utah-jazz-logo.png",
    "Washington Wizards": "NBA_LOGOs/nba-washington-wizards-logo.png",
}

# Caching player data and model
@st.cache_resource
def load_player_data():
    return pd.read_csv("player_data.csv")

@st.cache_resource
def load_rf_model():
    return joblib.load("rf_injury_change_model.pkl")

# Main application
# Main application
def main():
    st.title("NBA Player Performance Predictor 🏀")
    st.markdown("""
    Use this tool to predict how a player's performance metrics might change
    if they experience a hypothetical injury.
    """)

    # Load data and model
    player_data = load_player_data()
    rf_model = load_rf_model()

    # Sidebar inputs
    with st.sidebar:
        st.header("Player & Injury Inputs")
        player_list = sorted(player_data['player_name'].dropna().unique())
        player_name = st.selectbox("Select Player", player_list)

        if player_name:
            # Filter data for the selected player
            player_row = player_data[player_data['player_name'] == player_name]
            team_name = player_row.iloc[0]['team_abbreviation']
            position = player_row.iloc[0]['position']
            stats_columns = ['age', 'player_height', 'player_weight']

            st.write(f"**Position**: {position}")
            st.write(f"**Team**: {team_name}")

            # Player stats
            default_stats = {stat: player_row.iloc[0][stat] for stat in stats_columns}
            for stat in default_stats.keys():
                default_stats[stat] = st.number_input(f"{stat}", value=default_stats[stat])

            # Injury details
            injury_type = st.selectbox("Select Hypothetical Injury", injury_types)
            default_days_injured = average_days_injured.get(injury_type, 30)
            days_injured = st.slider("Estimated Days Injured", 0, 365, int(default_days_injured))
            injury_occurrences = st.number_input("Injury Occurrences", min_value=0, value=1)

            # Prepare data for prediction
            input_data = pd.DataFrame([{
                "days_injured": days_injured,
                "injury_occurrences": injury_occurrences,
                "position": position_mapping.get(position, 0),
                "injury_type": injury_type,
                **default_stats
            }])
            input_data["injury_type"] = pd.factorize(input_data["injury_type"])[0]

            st.header("Prediction Results")
            if st.button("Predict"):
                predictions = rf_model.predict(input_data)
                predictions = [round(float(pred), 2) for pred in predictions]

                # Display prediction results
                prediction_columns = ["Predicted Change in PTS", "Predicted Change in REB", "Predicted Change in AST"]
                result_df = pd.DataFrame([predictions], columns=prediction_columns)
                st.table(result_df)
            
                # Main content layout
    st.divider()
    st.header("Player Overview")
    col1, col2 = st.columns([1, 2])

    with col1:
        st.subheader("Player Details")
        st.metric("Age", default_stats['age'])
        st.metric("Height (cm)", default_stats['player_height'])
        st.metric("Weight (kg)", default_stats['player_weight'])

    with col2:
        # Display team logo
        if team_name in team_logo_paths:
            logo_path = team_logo_paths[team_name]
            try:
                logo_image = Image.open(logo_path)
                st.image(logo_image, caption=f"{team_name} Logo", use_column_width=True)
            except FileNotFoundError:
                st.error(f"Logo for {team_name} not found.")


    # Graphs for PPG, AST, and REB
    st.divider()
    st.header("Player Performance Graphs")

    if st.button("Show Performance Graphs"):
        # Filter data for the selected player
        player_data_filtered = player_data[player_data["player_name"] == player_name].sort_values(by="season")

        # Ensure all seasons are included
        all_seasons = pd.Series(range(player_data["season"].min(), player_data["season"].max() + 1))
        player_data_filtered = (
            pd.DataFrame({"season": all_seasons})
            .merge(player_data_filtered, on="season", how="left")
            .fillna({"pts": 0, "ast": 0, "reb": 0})  # Fill missing values
        )

        if not player_data_filtered.empty:
            # PPG Graph
            fig_ppg = px.line(
                player_data_filtered,
                x="season",
                y="pts",
                title=f"{player_name}: Points Per Game (PPG) Over Seasons",
                labels={"pts": "Points Per Game (PPG)", "season": "Season"},
                markers=True
            )
            fig_ppg.update_layout(template="plotly_white")

            # AST Graph
            fig_ast = px.line(
                player_data_filtered,
                x="season",
                y="ast",
                title=f"{player_name}: Assists Per Game (AST) Over Seasons",
                labels={"ast": "Assists Per Game (AST)", "season": "Season"},
                markers=True
            )
            fig_ast.update_layout(template="plotly_white")

            # REB Graph
            fig_reb = px.line(
                player_data_filtered,
                x="season",
                y="reb",
                title=f"{player_name}: Rebounds Per Game (REB) Over Seasons",
                labels={"reb": "Rebounds Per Game (REB)", "season": "Season"},
                markers=True
            )
            fig_reb.update_layout(template="plotly_white")

            # Display graphs
            st.plotly_chart(fig_ppg, use_container_width=True)
            st.plotly_chart(fig_ast, use_container_width=True)
            st.plotly_chart(fig_reb, use_container_width=True)
        else:
            st.error("No data available for the selected player.")

    # Footer
    st.divider()
    st.markdown("""
    ### About This Tool
    This application predicts how injuries might impact an NBA player's performance using machine learning models. Data is based on historical player stats and injuries.
    """)

if __name__ == "__main__":
    main()