Update app.py

app.py

@@ -47,204 +47,257 @@ def init_baselines():
 
 adp_table, stacks_table, proj_table = init_baselines()
 
-# tab1, tab2, tab3 = st.tabs(["ADPs and Ranks", "Team Projections", "Stack Tool", "Player Prop Simulations", "Stat Specific Simulations", "Bet Sheet"])
+tab1, tab2, tab3, tab4 = st.tabs(["ADPs and Ranks", "Team Projections", 'Player Projections', "Stack Finder"])
 
 def convert_df_to_csv(df):
     return df.to_csv().encode('utf-8')
 
-col1, col2 = st.columns([1, 5])
-
-with col1:
-    if st.button("Load/Reset Data", key='reset4'):
-          st.cache_data.clear()
-          adp_table, stacks_table, proj_table = init_baselines()
-    site_var2 = st.radio("What site are you playing?", ('Underdog', 'MFL10'), key='site_var2')
-    split_var2 = st.radio("Would you like to run stack analysis for the full slate or individual teams?", ('All Teams', 'Specific Teams'), key='split_var2')
-    if split_var2 == 'Specific Teams':
-        team_var2 = st.multiselect('Which teams would you like to include in the analysis?', options = adp_table['Team'].unique(), key='team_var2')
-    elif split_var2 == 'All Teams':
-        team_var2 = adp_table.Team.unique().tolist()
-    pos_split2 = st.radio("Are you viewing all positions, specific groups, or specific positions?", ('All Positions', 'Specific Positions'), key='pos_split2')
-    if pos_split2 == 'Specific Positions':
-        pos_var2 = st.multiselect('What Positions would you like to view?', options = ['QB', 'RB', 'WR', 'TE'])
-    elif pos_split2 == 'All Positions':
-        pos_var2 = 'All'
-    if site_var2 == 'Underdog':
-        adp_dict = dict(zip(adp_table.Player, adp_table.Underdog))
-    elif site_var2 == 'MFL10':
-       adp_dict = dict(zip(adp_table.Player, adp_table.MFL10))
-    size_var2 = st.number_input('What size of stacks are you analyzing?', min_value = 3, max_value = 6, step=1)
-    stack_size = size_var2
-
-    team_dict = dict(zip(adp_table.Player, adp_table.Team))
-    proj_dict = dict(zip(adp_table.Player, adp_table.Projection))
-    diff_dict = dict(zip(adp_table.Player, adp_table.Diff))
-
-with col2:
-    stack_hold_container = st.empty()
-    if st.button('Run stack analysis'):
-        comb_list = []
-        if pos_split2 == 'All Positions':
-            slate_teams = adp_table['Team'].values.tolist()
-            raw_baselines = adp_table.copy()
-        elif pos_split2 != 'All Positions':
-            slate_teams = adp_table['Team'].values.tolist()
-            raw_baselines = adp_table[adp_table['Position'].str.contains('|'.join(pos_var2))]
-
-        for cur_team in team_var2:
-            working_baselines = raw_baselines.copy()
-            working_baselines = working_baselines[working_baselines['Team'] == cur_team]
-            order_list = working_baselines['Player']
-
-            comb = combinations(order_list, stack_size)
-
-            for i in list(comb):
-                comb_list.append(i)
-
-        comb_DF = pd.DataFrame(comb_list)
-
-        if stack_size == 3:
-            comb_DF['Team'] = comb_DF[0].map(team_dict)
-
-            comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(3)]).sum(), axis=1)
-
-            comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
-            comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
-            comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
-
-            comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(3)]).mean(), axis=1)
-            
-        elif stack_size == 4:
-            comb_DF['Team'] = comb_DF[0].map(team_dict)
-
-            comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(4)]).sum(), axis=1)
-
-            comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
-            comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
-            comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
-            comb_DF['ADP_4'] = comb_DF[3].map(adp_dict)
-
-            comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(4)]).mean(), axis=1)
-            
-        elif stack_size == 5:
-            comb_DF['Team'] = comb_DF[0].map(team_dict)
-
-            comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(5)]).sum(), axis=1)
-
-            comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
-            comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
-            comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
-            comb_DF['ADP_4'] = comb_DF[3].map(adp_dict)
-            comb_DF['ADP_5'] = comb_DF[4].map(adp_dict)
-
-            comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(5)]).mean(), axis=1)
+with tab1:
+    col1, col2 = st.columns([1, 5])
+    
+    with col1:
+        if st.button("Load/Reset Data", key='reset1'):
+              st.cache_data.clear()
+              adp_table, stacks_table, proj_table = init_baselines()
+        site_var1 = st.radio("What site are you playing?", ('Underdog', 'MFL10'), key='site_var1')
+        split_var1 = st.radio("Would you like to run stack analysis for the full slate or individual teams?", ('All Teams', 'Specific Teams'), key='split_var1')
+        if split_var1 == 'Specific Teams':
+            team_var1 = st.multiselect('Which teams would you like to include in the analysis?', options = adp_table['Team'].unique(), key='team_var1')
+        elif split_var1 == 'All Teams':
+            team_var1 = adp_table.Team.unique().tolist()
+        pos_split1 = st.radio("Are you viewing all positions, specific groups, or specific positions?", ('All Positions', 'Specific Positions'), key='pos_split1')
+        if pos_split1 == 'Specific Positions':
+            pos_var1 = st.multiselect('What Positions would you like to view?', options = ['QB', 'RB', 'WR', 'TE'])
+        elif pos_split1 == 'All Positions':
+            pos_var1 = adp_table.Position.unique().tolist()
+    
+    with col2:
+        stack_hold_container = st.empty()
+        working_baselines = adp_table.copy()
         
-        elif stack_size == 6:
-            comb_DF['Team'] = comb_DF[0].map(team_dict)
-
-            comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(6)]).sum(), axis=1)
-
-            comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
-            comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
-            comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
-            comb_DF['ADP_4'] = comb_DF[3].map(adp_dict)
-            comb_DF['ADP_5'] = comb_DF[4].map(adp_dict)
-            comb_DF['ADP_6'] = comb_DF[5].map(adp_dict)
+        if pos_split1 == 'All Positions':
+            raw_baselines = working_baselines
+        elif pos_split1 != 'All Positions':
+            raw_baselines = working_baselines[working_baselines['Position'].str.contains('|'.join(pos_var1))]
+
+        if split_var1 == 'All Teams':
+            raw_baselines = raw_baselines
+        elif split_var1 != 'All Teams':
+            raw_baselines = raw_baselines[raw_baselines['Team'].str.contains('|'.join(team_var1))]
             
-            comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(6)]).mean(), axis=1)
-
-        comb_DF = comb_DF.sort_values(by='Proj', ascending=False)
-
-        cut_var = 0
-
-        if stack_size == 3:
-            while cut_var <= int(len(comb_DF)):
-                try:
-                    if int(cut_var) == 0:
-                        cur_proj = float(comb_DF.iat[cut_var,4])
-                        cur_own = 0
-                    elif int(cut_var) >= 1:
-                        check_own = float(comb_DF.iat[cut_var,8])
-                        if check_own < cur_own:
-                            comb_DF = comb_DF.drop([cut_var])
-                            cur_own = cur_own
-                            cut_var = cut_var - 1
-                            comb_DF = comb_DF.reset_index()
-                            comb_DF = comb_DF.drop(['index'], axis=1)
-                        elif check_own >= cur_own:
-                            cur_own = float(comb_DF.iat[cut_var,8])
-                            cut_var = cut_var
-                    cut_var += 1
-                except:
-                    cut_var += 1
-                    
-        elif stack_size == 4:
-            while cut_var <= int(len(comb_DF)):
-                try:
-                    if int(cut_var) == 0:
-                        cur_proj = float(comb_DF.iat[cut_var,5])
-                        cur_own = 0
-                    elif int(cut_var) >= 1:
-                        check_own = float(comb_DF.iat[cut_var,10])
-                        if check_own < cur_own:
-                            comb_DF = comb_DF.drop([cut_var])
-                            cur_own = cur_own
-                            cut_var = cut_var - 1
-                            comb_DF = comb_DF.reset_index()
-                            comb_DF = comb_DF.drop(['index'], axis=1)
-                        elif check_own >= cur_own:
-                            cur_own = float(comb_DF.iat[cut_var,10])
-                            cut_var = cut_var
-                    cut_var += 1
-                except:
-                    cut_var += 1
-        elif stack_size == 5:
-            while cut_var <= int(len(comb_DF)):
-                try:
-                    if int(cut_var) == 0:
-                        cur_proj = float(comb_DF.iat[cut_var,6])
-                        cur_own = 0
-                    elif int(cut_var) >= 1:
-                        check_own = float(comb_DF.iat[cut_var,12])
-                        if check_own < cur_own:
-                            comb_DF = comb_DF.drop([cut_var])
-                            cur_own = cur_own
-                            cut_var = cut_var - 1
-                            comb_DF = comb_DF.reset_index()
-                            comb_DF = comb_DF.drop(['index'], axis=1)
-                        elif check_own >= cur_own:
-                            cur_own = float(comb_DF.iat[cut_var,12])
-                            cut_var = cut_var
-                    cut_var += 1
-                except:
-                    cut_var += 1
-        elif stack_size == 6:
-            while cut_var <= int(len(comb_DF)):
-                try:
-                    if int(cut_var) == 0:
-                        cur_proj = float(comb_DF.iat[cut_var,7])
-                        cur_own = 0
-                    elif int(cut_var) >= 1:
-                        check_own = float(comb_DF.iat[cut_var,14])
-                        if check_own < cur_own:
-                            comb_DF = comb_DF.drop([cut_var])
-                            cur_own = cur_own
-                            cut_var = cut_var - 1
-                            comb_DF = comb_DF.reset_index()
-                            comb_DF = comb_DF.drop(['index'], axis=1)
-                        elif check_own >= cur_own:
-                            cur_own = float(comb_DF.iat[cut_var,14])
-                            cut_var = cut_var
-                    cut_var += 1
-                except:
-                    cut_var += 1
-
+        display_frame = raw_baselines.copy()
+        
         with stack_hold_container:
             stack_hold_container = st.empty()
-            st.dataframe(comb_DF.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), use_container_width = True)
+            st.dataframe(display_frame.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), use_container_width = True)
         st.download_button(
                 label="Export Tables",
-                data=convert_df_to_csv(comb_DF),
+                data=convert_df_to_csv(display_frame),
                 file_name='NFL_Stack_Options_export.csv',
                 mime='text/csv',
-        )
+        )
+with tab2:
+    st.write('working on it')
+with tab3:
+    st.write('working on it')
+with tab4:
+    col1, col2 = st.columns([1, 5])
+    
+    with col1:
+        if st.button("Load/Reset Data", key='reset4'):
+              st.cache_data.clear()
+              adp_table, stacks_table, proj_table = init_baselines()
+        site_var4 = st.radio("What site are you playing?", ('Underdog', 'MFL10'), key='site_var2')
+        split_var4 = st.radio("Would you like to run stack analysis for the full slate or individual teams?", ('All Teams', 'Specific Teams'), key='split_var4')
+        if split_var4 == 'Specific Teams':
+            team_var4 = st.multiselect('Which teams would you like to include in the analysis?', options = adp_table['Team'].unique(), key='team_var4')
+        elif split_var4 == 'All Teams':
+            team_var4 = adp_table.Team.unique().tolist()
+        pos_split4 = st.radio("Are you viewing all positions, specific groups, or specific positions?", ('All Positions', 'Specific Positions'), key='pos_split4')
+        if pos_split4 == 'Specific Positions':
+            pos_var4 = st.multiselect('What Positions would you like to view?', options = ['QB', 'RB', 'WR', 'TE'], key='pos_var4')
+        elif pos_split4 == 'All Positions':
+            pos_var4 = adp_table.Position.unique().tolist()
+        if site_var4 == 'Underdog':
+            adp_dict = dict(zip(adp_table.Player, adp_table.Underdog))
+        elif site_var4 == 'MFL10':
+           adp_dict = dict(zip(adp_table.Player, adp_table.MFL10))
+        size_var4 = st.number_input('What size of stacks are you analyzing?', min_value = 3, max_value = 6, step=1)
+        stack_size = size_var4
+        cut_var4 = st.radio("Do you want to remove stacks with a negative average value?", ('Yes', 'No'), key='cut_var4')
+        if cut_var4 == "Yes":
+            cut_sequence = 1
+        elif cut_var4 == "No":
+            cut_sequence = 0
+    
+        team_dict = dict(zip(adp_table.Player, adp_table.Team))
+        proj_dict = dict(zip(adp_table.Player, adp_table.Projection))
+        diff_dict = dict(zip(adp_table.Player, adp_table.Diff))
+    
+    with col2:
+        stack_hold_container = st.empty()
+        if st.button('Run stack analysis'):
+            comb_list = []
+            if pos_split4 == 'All Positions':
+                raw_baselines = adp_table.copy()
+            elif pos_split4 != 'All Positions':
+                raw_baselines = adp_table[adp_table['Position'].str.contains('|'.join(pos_var4))]
+    
+            for cur_team in team_var4:
+                working_baselines = raw_baselines.copy()
+                working_baselines = working_baselines[working_baselines['Team'] == cur_team]
+                order_list = working_baselines['Player']
+    
+                comb = combinations(order_list, stack_size)
+    
+                for i in list(comb):
+                    comb_list.append(i)
+    
+            comb_DF = pd.DataFrame(comb_list)
+    
+            if stack_size == 3:
+                comb_DF['Team'] = comb_DF[0].map(team_dict)
+    
+                comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(3)]).sum(), axis=1)
+    
+                comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
+                comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
+                comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
+    
+                comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(3)]).mean(), axis=1)
+                
+            elif stack_size == 4:
+                comb_DF['Team'] = comb_DF[0].map(team_dict)
+    
+                comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(4)]).sum(), axis=1)
+    
+                comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
+                comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
+                comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
+                comb_DF['ADP_4'] = comb_DF[3].map(adp_dict)
+    
+                comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(4)]).mean(), axis=1)
+                
+            elif stack_size == 5:
+                comb_DF['Team'] = comb_DF[0].map(team_dict)
+    
+                comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(5)]).sum(), axis=1)
+    
+                comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
+                comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
+                comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
+                comb_DF['ADP_4'] = comb_DF[3].map(adp_dict)
+                comb_DF['ADP_5'] = comb_DF[4].map(adp_dict)
+    
+                comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(5)]).mean(), axis=1)
+            
+            elif stack_size == 6:
+                comb_DF['Team'] = comb_DF[0].map(team_dict)
+    
+                comb_DF['Proj'] = comb_DF.apply(lambda row: pd.Series([proj_dict.get(row[i], None) for i in range(6)]).sum(), axis=1)
+    
+                comb_DF['ADP_1'] = comb_DF[0].map(adp_dict)
+                comb_DF['ADP_2'] = comb_DF[1].map(adp_dict)
+                comb_DF['ADP_3'] = comb_DF[2].map(adp_dict)
+                comb_DF['ADP_4'] = comb_DF[3].map(adp_dict)
+                comb_DF['ADP_5'] = comb_DF[4].map(adp_dict)
+                comb_DF['ADP_6'] = comb_DF[5].map(adp_dict)
+                
+                comb_DF['Value'] = comb_DF.apply(lambda row: pd.Series([diff_dict.get(row[i], None) for i in range(6)]).mean(), axis=1)
+    
+            comb_DF = comb_DF.sort_values(by='Proj', ascending=False)
+            
+            if cut_sequence == 1:
+                cut_var = 0
+        
+                if stack_size == 3:
+                    while cut_var <= int(len(comb_DF)):
+                        try:
+                            if int(cut_var) == 0:
+                                cur_proj = float(comb_DF.iat[cut_var,4])
+                                cur_own = 0
+                            elif int(cut_var) >= 1:
+                                check_own = float(comb_DF.iat[cut_var,8])
+                                if check_own < cur_own:
+                                    comb_DF = comb_DF.drop([cut_var])
+                                    cur_own = cur_own
+                                    cut_var = cut_var - 1
+                                    comb_DF = comb_DF.reset_index()
+                                    comb_DF = comb_DF.drop(['index'], axis=1)
+                                elif check_own >= cur_own:
+                                    cur_own = float(comb_DF.iat[cut_var,8])
+                                    cut_var = cut_var
+                            cut_var += 1
+                        except:
+                            cut_var += 1
+                            
+                elif stack_size == 4:
+                    while cut_var <= int(len(comb_DF)):
+                        try:
+                            if int(cut_var) == 0:
+                                cur_proj = float(comb_DF.iat[cut_var,5])
+                                cur_own = 0
+                            elif int(cut_var) >= 1:
+                                check_own = float(comb_DF.iat[cut_var,10])
+                                if check_own < cur_own:
+                                    comb_DF = comb_DF.drop([cut_var])
+                                    cur_own = cur_own
+                                    cut_var = cut_var - 1
+                                    comb_DF = comb_DF.reset_index()
+                                    comb_DF = comb_DF.drop(['index'], axis=1)
+                                elif check_own >= cur_own:
+                                    cur_own = float(comb_DF.iat[cut_var,10])
+                                    cut_var = cut_var
+                            cut_var += 1
+                        except:
+                            cut_var += 1
+                elif stack_size == 5:
+                    while cut_var <= int(len(comb_DF)):
+                        try:
+                            if int(cut_var) == 0:
+                                cur_proj = float(comb_DF.iat[cut_var,6])
+                                cur_own = 0
+                            elif int(cut_var) >= 1:
+                                check_own = float(comb_DF.iat[cut_var,12])
+                                if check_own < cur_own:
+                                    comb_DF = comb_DF.drop([cut_var])
+                                    cur_own = cur_own
+                                    cut_var = cut_var - 1
+                                    comb_DF = comb_DF.reset_index()
+                                    comb_DF = comb_DF.drop(['index'], axis=1)
+                                elif check_own >= cur_own:
+                                    cur_own = float(comb_DF.iat[cut_var,12])
+                                    cut_var = cut_var
+                            cut_var += 1
+                        except:
+                            cut_var += 1
+                elif stack_size == 6:
+                    while cut_var <= int(len(comb_DF)):
+                        try:
+                            if int(cut_var) == 0:
+                                cur_proj = float(comb_DF.iat[cut_var,7])
+                                cur_own = 0
+                            elif int(cut_var) >= 1:
+                                check_own = float(comb_DF.iat[cut_var,14])
+                                if check_own < cur_own:
+                                    comb_DF = comb_DF.drop([cut_var])
+                                    cur_own = cur_own
+                                    cut_var = cut_var - 1
+                                    comb_DF = comb_DF.reset_index()
+                                    comb_DF = comb_DF.drop(['index'], axis=1)
+                                elif check_own >= cur_own:
+                                    cur_own = float(comb_DF.iat[cut_var,14])
+                                    cut_var = cut_var
+                            cut_var += 1
+                        except:
+                            cut_var += 1
+    
+            with stack_hold_container:
+                stack_hold_container = st.empty()
+                st.dataframe(comb_DF.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), use_container_width = True)
+            st.download_button(
+                    label="Export Tables",
+                    data=convert_df_to_csv(comb_DF),
+                    file_name='NFL_Stack_Options_export.csv',
+                    mime='text/csv',
+            )