Implement Fantasy Football VORP Calculator with user-configurable league settings and data loading from external APIs. Added functions for calculating player rankings, replacement values, and VORP metrics. Enhanced user interface for league configuration and data display.

src/streamlit_app.py

@@ -1,40 +1,408 @@
-import altair as alt
-import numpy as np
 import pandas as pd
+import numpy as np
+import requests
+import math
 import streamlit as st
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+Dwain_proj = 'https://sheetdb.io/api/v1/svino07zkd6j6?sheet=2025_NFL_Proj_Dist'
+dwain_ranks = 'https://sheetdb.io/api/v1/ax8b1ms11bbzt?sheet=Dwain_Season'
+
+# Default configuration dictionaries
+type_flex_percentiles = {
+    'Half PPR': {
+        'RB': .40,
+        'WR': .55, 
+        'TE': .05,
+    },
+    'PPR': {
+        'RB': .40,
+        'WR': .55, 
+        'TE': .05,
+    },
+    'Standard': {
+        'RB': .40,
+        'WR': .55, 
+        'TE': .05,
+    },
+    'Superflex': {
+        'QB': .95,
+        'RB': .02,
+        'WR': .03, 
+        'TE': .00,
+    },
+    'TE Premium': {
+        'RB': .35,
+        'WR': .50,
+        'TE': .15,
+    }
+}
+
+pos_vorp_limiters = {
+    'PPR': {
+        'QB': .5,
+        'RB': .75,
+        'WR': .75,
+        'TE': .5,
+    },
+    'Standard': {
+        'QB': .25,
+        'RB': .75,
+        'WR': .75,
+        'TE': .5,
+    },
+    'Superflex': {  
+        'QB': .5,
+        'RB': .75,
+        'WR': .75,
+        'TE': .5,
+    },
+    'TE Premium': {
+        'QB': .5,
+        'RB': .75,
+        'WR': .75,
+        'TE': .5,
+    },
+    'Half PPR': {
+        'QB': .5,
+        'RB': .75,
+        'WR': .75,
+        'TE': .5,
+    },
+}
+
+flex_multipliers = {
+    'Half PPR': {
+        'QB': 2,
+        'RB': 2,
+        'WR': 2,
+        'TE': 2,
+    },
+    'PPR': {    
+        'QB': 2,
+        'RB': 2,
+        'WR': 2,
+        'TE': 2,
+    },
+    'Standard': {
+        'QB': 2,
+        'RB': 2,
+        'WR': 2,
+        'TE': 2,
+    },
+    'Superflex': {
+        'QB': 4,
+        'RB': 2,
+        'WR': 2,
+        'TE': 2,
+    },
+    'TE Premium': {
+        'QB': 2,
+        'RB': 2,
+        'WR': 2,
+        'TE': 2,
+    },
+}
+
+base_settings = {
+    'TEAMS': 12,
+    'QB': 1,
+    'RB': 2,
+    'WR': 3,
+    'TE': 1,
+    'FLEX': 1,
+    'BENCH': 6,
+    'TYPE': 'Half PPR'
+}
+
+league_settings = {
+    'TEAMS': 12,
+    'QB': 1,
+    'RB': 2,
+    'WR': 3,
+    'TE': 1,
+    'FLEX': 2,
+    'BENCH': 6,
+    'TYPE': 'Superflex'
+}
+
+def create_user_config_interface():
+    """Create Streamlit interface for user configuration"""
+    st.sidebar.header("League Configuration")
+    
+    # League Type Selection
+    league_type = st.sidebar.selectbox(
+        "League Type",
+        ['Half PPR', 'PPR', 'Standard', 'Superflex', 'TE Premium'],
+        index=0
+    )
+    
+    # League Settings
+    st.sidebar.subheader("League Settings")
+    teams = st.sidebar.number_input("Number of Teams", min_value=8, max_value=16, value=12)
+    qb_starters = st.sidebar.number_input("QB Starters", min_value=1, max_value=2, value=1)
+    rb_starters = st.sidebar.number_input("RB Starters", min_value=1, max_value=3, value=2)
+    wr_starters = st.sidebar.number_input("WR Starters", min_value=1, max_value=4, value=3)
+    te_starters = st.sidebar.number_input("TE Starters", min_value=1, max_value=2, value=1)
+    flex_spots = st.sidebar.number_input("Flex Spots", min_value=0, max_value=3, value=1)
+    bench_spots = st.sidebar.number_input("Bench Spots", min_value=0, max_value=10, value=6)
+    
+    # Update league settings based on user input
+    user_league_settings = {
+        'TEAMS': teams,
+        'QB': qb_starters,
+        'RB': rb_starters,
+        'WR': wr_starters,
+        'TE': te_starters,
+        'FLEX': flex_spots,
+        'BENCH': bench_spots,
+        'TYPE': league_type
+    }
+    
+    # Flex Percentiles Configuration
+    st.sidebar.subheader("Flex Position Percentiles")
+    if league_type == 'Superflex':
+        qb_flex_pct = st.sidebar.slider("QB Flex %", 0.0, 1.0, 0.95, 0.01)
+        rb_flex_pct = st.sidebar.slider("RB Flex %", 0.0, 1.0, 0.02, 0.01)
+        wr_flex_pct = st.sidebar.slider("WR Flex %", 0.0, 1.0, 0.03, 0.01)
+        te_flex_pct = st.sidebar.slider("TE Flex %", 0.0, 1.0, 0.00, 0.01)
+        
+        user_flex_percentiles = {
+            'QB': qb_flex_pct,
+            'RB': rb_flex_pct,
+            'WR': wr_flex_pct,
+            'TE': te_flex_pct,
+        }
+    else:
+        rb_flex_pct = st.sidebar.slider("RB Flex %", 0.0, 1.0, type_flex_percentiles[league_type]['RB'], 0.01)
+        wr_flex_pct = st.sidebar.slider("WR Flex %", 0.0, 1.0, type_flex_percentiles[league_type]['WR'], 0.01)
+        te_flex_pct = st.sidebar.slider("TE Flex %", 0.0, 1.0, type_flex_percentiles[league_type]['TE'], 0.01)
+        
+        user_flex_percentiles = {
+            'RB': rb_flex_pct,
+            'WR': wr_flex_pct,
+            'TE': te_flex_pct,
+        }
+    
+    # Flex Multipliers Configuration
+    st.sidebar.subheader("Position Multipliers")
+    qb_mult = st.sidebar.number_input("QB Multiplier", min_value=1.0, max_value=5.0, value=float(flex_multipliers[league_type]['QB']), step=0.5)
+    rb_mult = st.sidebar.number_input("RB Multiplier", min_value=1.0, max_value=5.0, value=float(flex_multipliers[league_type]['RB']), step=0.5)
+    wr_mult = st.sidebar.number_input("WR Multiplier", min_value=1.0, max_value=5.0, value=float(flex_multipliers[league_type]['WR']), step=0.5)
+    te_mult = st.sidebar.number_input("TE Multiplier", min_value=1.0, max_value=5.0, value=float(flex_multipliers[league_type]['TE']), step=0.5)
+    
+    user_flex_multipliers = {
+        'QB': qb_mult,
+        'RB': rb_mult,
+        'WR': wr_mult,
+        'TE': te_mult,
+    }
+    
+    # VORP Limiters Configuration
+    st.sidebar.subheader("VORP Rank Adjustments")
+    qb_vorp_lim = st.sidebar.slider("QB VORP Limiter", 0.0, 1.0, pos_vorp_limiters[league_type]['QB'], 0.01)
+    rb_vorp_lim = st.sidebar.slider("RB VORP Limiter", 0.0, 1.0, pos_vorp_limiters[league_type]['RB'], 0.01)
+    wr_vorp_lim = st.sidebar.slider("WR VORP Limiter", 0.0, 1.0, pos_vorp_limiters[league_type]['WR'], 0.01)
+    te_vorp_lim = st.sidebar.slider("TE VORP Limiter", 0.0, 1.0, pos_vorp_limiters[league_type]['TE'], 0.01)
+    
+    user_pos_vorp_limiters = {
+        'QB': qb_vorp_lim,
+        'RB': rb_vorp_lim,
+        'WR': wr_vorp_lim,
+        'TE': te_vorp_lim,
+    }
+    
+    return user_league_settings, user_flex_percentiles, user_flex_multipliers, user_pos_vorp_limiters
+
+def load_projections_data(api: str) -> pd.DataFrame:
+    calc_columns = ['Ru Yds', 'Ru TDs', 'Rec', 'Rec Yds', 'Rec TDs', 'P Yds', 'P TDs', 'INTs']
+    ppr_values = [.1, 6, 1, .1, 6, .04, 4, -1]
+    halfPpr_values = [.1, 6, .5, .1, 6, .04, 4, -1]
+    standard_values = [.1, 6, 0, .1, 6, .04, 4, -1]
+    init_data = requests.get(api)
+    proj_dataframe = pd.DataFrame(init_data.json())
+    for col in calc_columns:
+        proj_dataframe[col] = proj_dataframe[col].astype(float)
+    proj_dataframe['halfPpr'] = proj_dataframe[calc_columns].dot(halfPpr_values)
+    proj_dataframe['ppr'] = proj_dataframe[calc_columns].dot(ppr_values)
+    proj_dataframe['standard'] = proj_dataframe[calc_columns].dot(standard_values)
+
+    fpts_df = proj_dataframe[['Name', 'SR_ID', 'Pos', 'halfPpr', 'ppr', 'standard']]
+    
+    return fpts_df
+
+def load_ranks_data(api: str) -> pd.DataFrame:
+    init_data = requests.get(api)
+    ranks_dataframe = pd.DataFrame(init_data.json())
+
+    ranks_dict = dict(zip(ranks_dataframe['SR_ID'], ranks_dataframe['Rank']))
+    return ranks_dict
+
+def create_position_frames(frame: pd.DataFrame, ranks: dict) -> pd.DataFrame:
+    qb_frame = frame[frame['Pos'] == 'QB'].sort_values(by='halfPpr', ascending=False)
+    rb_frame = frame[frame['Pos'] == 'RB'].sort_values(by='halfPpr', ascending=False)
+    wr_frame = frame[frame['Pos'] == 'WR'].sort_values(by='halfPpr', ascending=False)
+    te_frame = frame[frame['Pos'] == 'TE'].sort_values(by='halfPpr', ascending=False)
+    
+    for slice in [qb_frame, rb_frame, wr_frame, te_frame]:
+        slice['Rank'] = slice['SR_ID'].map(ranks).replace(np.nan, 0).astype(int)
+        slice = slice[slice['Rank'] != 0]
+        slice = slice.sort_values(by='Rank', ascending=True)
+    
+    overall_frame = pd.concat([qb_frame, rb_frame, wr_frame, te_frame]).reset_index(drop=True)
+    
+    return overall_frame
+
+def designate_custom_position_reqs(league_settings: dict, flex_percentiles: dict, flex_multipliers: dict) -> dict:
+    qb_base = league_settings['QB'] * league_settings['TEAMS']
+    rb_base = league_settings['RB'] * league_settings['TEAMS']
+    wr_base = league_settings['WR'] * league_settings['TEAMS']
+    te_base = league_settings['TE'] * league_settings['TEAMS']
+
+    qb_rv_index = math.ceil((qb_base) * flex_multipliers[league_settings['TYPE']]['QB'])
+    rb_rv_index = math.ceil((rb_base + ((league_settings['TEAMS'] * league_settings['FLEX']) * flex_percentiles[league_settings['TYPE']]['RB'])) * flex_multipliers[league_settings['TYPE']]['RB'])
+    wr_rv_index = math.ceil((wr_base + ((league_settings['TEAMS'] * league_settings['FLEX']) * flex_percentiles[league_settings['TYPE']]['WR'])) * flex_multipliers[league_settings['TYPE']]['WR'])
+    te_rv_index = math.ceil((te_base + ((league_settings['TEAMS'] * league_settings['FLEX']) * flex_percentiles[league_settings['TYPE']]['TE'])) * flex_multipliers[league_settings['TYPE']]['TE'])
+    
+    print(f"Need {qb_rv_index} for QB in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+    print(f"Need {rb_rv_index} for RB in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+    print(f"Need {wr_rv_index} for WR in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+    print(f"Need {te_rv_index} for TE in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+
+    pos_reqs = {
+        'QB': qb_rv_index,
+        'RB': rb_rv_index,
+        'WR': wr_rv_index,
+        'TE': te_rv_index,
+    }
+    
+    return pos_reqs
+
+def designate_base_position_reqs(league_settings: dict, flex_percentiles: dict, flex_multipliers: dict) -> dict:
+    qb_base = league_settings['QB'] * league_settings['TEAMS']
+    rb_base = league_settings['RB'] * league_settings['TEAMS']
+    wr_base = league_settings['WR'] * league_settings['TEAMS']
+    te_base = league_settings['TE'] * league_settings['TEAMS']
+
+    qb_rv_index = math.ceil(qb_base * flex_multipliers[league_settings['TYPE']]['QB'])
+    rb_rv_index = math.ceil((rb_base + ((league_settings['TEAMS'] * league_settings['FLEX']) * flex_percentiles[league_settings['TYPE']]['RB'])) * flex_multipliers[league_settings['TYPE']]['RB'])
+    wr_rv_index = math.ceil((wr_base + ((league_settings['TEAMS'] * league_settings['FLEX']) * flex_percentiles[league_settings['TYPE']]['WR'])) * flex_multipliers[league_settings['TYPE']]['WR'])
+    te_rv_index = math.ceil((te_base + ((league_settings['TEAMS'] * league_settings['FLEX']) * flex_percentiles[league_settings['TYPE']]['TE'])) * flex_multipliers[league_settings['TYPE']]['TE'])
+    
+    print(f"Need {qb_rv_index} for QB in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+    print(f"Need {rb_rv_index} for RB in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+    print(f"Need {wr_rv_index} for WR in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+    print(f"Need {te_rv_index} for TE in {league_settings['TEAMS']} teams with type {league_settings['TYPE']}")
+
+    pos_reqs = {
+        'QB': qb_rv_index,
+        'RB': rb_rv_index,
+        'WR': wr_rv_index,
+        'TE': te_rv_index,
+    }
+    
+    return pos_reqs
+
+def create_halfPpr_rv(frame: pd.DataFrame, pos_reqs: dict) -> dict:
+
+    rv_dict = {}
+
+    for positions in ['QB', 'RB', 'WR', 'TE']:
+        rv_dict[f'{positions}'] = frame[frame['Pos'] == positions].head(pos_reqs[positions]).reset_index(drop=True)['halfPpr'].tail(1).values[0]
+
+    return rv_dict
+
+def create_custom_rv(frame: pd.DataFrame, pos_reqs: dict, league_settings: dict) -> dict:
+
+    if league_settings['TYPE'] == 'Half PPR':
+        rv_type = 'halfPpr'
+    elif league_settings['TYPE'] == 'PPR':
+        rv_type = 'ppr'
+    elif league_settings['TYPE'] == 'Standard':
+        rv_type = 'standard'
+    elif league_settings['TYPE'] == 'Superflex':
+        rv_type = 'halfPpr'
+
+    rv_dict = {}
+
+    for positions in ['QB', 'RB', 'WR', 'TE']:
+        rv_dict[f'{positions}'] = frame[frame['Pos'] == positions].head(pos_reqs[positions]).reset_index(drop=True)[rv_type].tail(1).values[0]
+
+    return rv_dict
+
+def assign_vorp(frame: pd.DataFrame, halfPpr_rv: dict, custom_rv: dict, league_settings: dict, pos_vorp_limiters: dict) -> pd.DataFrame:
+    if league_settings['TYPE'] == 'Half PPR':
+        rv_type = 'halfPpr'
+    elif league_settings['TYPE'] == 'PPR':
+        rv_type = 'ppr'
+    elif league_settings['TYPE'] == 'Standard':
+        rv_type = 'standard'
+    elif league_settings['TYPE'] == 'Superflex':
+        rv_type = 'halfPpr'
+
+    vorp_frame = pd.DataFrame()
+    for positions in ['QB', 'RB', 'WR', 'TE']:
+        pos_frame = frame[frame['Pos'] == positions]
+        pos_frame = pos_frame[pos_frame['Rank'] != 0].reset_index(drop=True)
+        pos_frame = pos_frame.sort_values(by='Rank', ascending=True)
+        
+        pos_frame['halfPpr_rv'] = halfPpr_rv[positions]
+        pos_frame['custom_rv'] = custom_rv[positions]
+        pos_frame['halfPpr_VORP'] = pos_frame['halfPpr'] - halfPpr_rv[positions]
+        pos_frame['custom_VORP'] = pos_frame[rv_type] - custom_rv[positions]
+        
+        vorp_frame = pd.concat([vorp_frame, pos_frame]).reset_index(drop=True)
+
+    vorp_frame['halfPpr_vorp_rank'] = vorp_frame['halfPpr_VORP'].rank(method='max', ascending=False)
+    vorp_frame['custom_vorp_rank'] = vorp_frame['custom_VORP'].rank(method='max', ascending=False)
+    vorp_frame['vorp_diff'] = vorp_frame['halfPpr_vorp_rank'] - vorp_frame['custom_vorp_rank']
+    for positions in ['QB', 'RB', 'WR', 'TE']:
+        vorp_frame.loc[vorp_frame['Pos'] == positions, 'Rank_Adjust'] = (vorp_frame['Rank'] - (vorp_frame['vorp_diff'] * pos_vorp_limiters[league_settings['TYPE']][positions])).astype(float)
+    vorp_frame['custom_rank'] = vorp_frame['Rank_Adjust'].rank(method='first', ascending=True)
+
+    print(vorp_frame.sort_values(by='custom_vorp_rank', ascending=True).head(50))
+
+    return vorp_frame.sort_values(by='custom_rank', ascending=True)
+
+def main():
+    st.title("Fantasy Football VORP Calculator")
+    st.write("Configure your league settings and analyze player values")
+    
+    # Get user configuration
+    user_league_settings, user_flex_percentiles, user_flex_multipliers, user_pos_vorp_limiters = create_user_config_interface()
+    
+    # Load data
+    try:
+        projections_df = load_projections_data(Dwain_proj)
+        ranks_dict = load_ranks_data(dwain_ranks)
+        
+        # Create position frames
+        position_df = create_position_frames(projections_df, ranks_dict)
+        
+        # Calculate position requirements
+        pos_reqs = designate_custom_position_reqs(user_league_settings, user_flex_percentiles, user_flex_multipliers)
+        
+        # Calculate replacement values
+        halfPpr_rv = create_halfPpr_rv(position_df, pos_reqs)
+        custom_rv = create_custom_rv(position_df, pos_reqs, user_league_settings)
+        
+        # Calculate VORP and rankings
+        final_df = assign_vorp(position_df, halfPpr_rv, custom_rv, user_league_settings, user_pos_vorp_limiters)
+        
+        # Display results
+        st.header("Player Rankings")
+        st.dataframe(final_df[['Name', 'Pos', 'Rank', 'custom_rank', 'halfPpr', 'custom_VORP', 'halfPpr_VORP']].head(50))
+        
+        # Position breakdown
+        st.header("Position Breakdown")
+        for pos in ['QB', 'RB', 'WR', 'TE']:
+            pos_df = final_df[final_df['Pos'] == pos].head(20)
+            st.subheader(f"Top {pos}s")
+            st.dataframe(pos_df[['Name', 'Rank', 'custom_rank', 'halfPpr', 'custom_VORP']])
+            
+    except Exception as e:
+        st.error(f"Error loading data: {str(e)}")
+        st.info("Please check your internet connection and try again.")
+
+if __name__ == "__main__":
+    main()
+