Replace distribute_preset with hedging_preset to manage player exposure in lineup generation. Update app.py to reflect the new preset option and remove the obsolete distribute_preset function. This change enhances the flexibility of lineup strategies by allowing users to hedge against high-exposure players while maintaining performance metrics.

app.py

@@ -22,7 +22,7 @@ from global_func.trim_portfolio import trim_portfolio
 from global_func.get_portfolio_names import get_portfolio_names
 from global_func.small_field_preset import small_field_preset
 from global_func.large_field_preset import large_field_preset
-from global_func.distribute_preset import distribute_preset
+from global_func.hedging_preset import hedging_preset
 
 freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
 stacking_sports = ['MLB', 'NHL', 'NFL']
@@ -1111,7 +1111,7 @@ with tab2:
             with st.expander('Presets'):
                 st.info("Still heavily in testing here, I'll announce when they are ready for use.")
                 with st.form(key='Small Field Preset'):
-                    preset_choice = st.selectbox("Preset", options=['Small Field (Heavy Own)', 'Large Field (Finish Percentile / Edge)', 'Distributed (Spread Out Risk)'], index=0)
+                    preset_choice = st.selectbox("Preset", options=['Small Field (Heavy Own)', 'Large Field (Finish Percentile / Edge)', 'Hedge Chalk (Manage Leverage)'], index=0)
                     lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1)
                     submitted = st.form_submit_button("Submit")
                     if submitted:
@@ -1119,8 +1119,8 @@ with tab2:
                             parsed_frame = small_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
                         elif preset_choice == 'Large Field (Finish Percentile / Edge)':
                             parsed_frame = large_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
-                        elif preset_choice == 'Distributed (Spread Out Risk)':
-                            parsed_frame = distribute_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
+                        elif preset_choice == 'Hedge Chalk (Manage Leverage)':
+                            parsed_frame = hedging_preset(st.session_state['working_frame'], lineup_target, st.session_state['projections_df'])
                         st.session_state['working_frame'] = parsed_frame.reset_index(drop=True)
                         st.session_state['export_merge'] = st.session_state['working_frame'].copy()
 

global_func/distribute_preset.py

@@ -1,80 +0,0 @@
-import pandas as pd
-import math
-
-def distribute_preset(portfolio: pd.DataFrame, lineup_target: int, exclude_cols: list):
-    
-    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
-    player_columns = [col for col in portfolio.columns if col not in excluded_cols]
-    for slack_var in range(1, 20):
-        init_portfolio = pd.DataFrame(columns=portfolio.columns)
-
-        for team in portfolio['Stack'].unique():
-            rows_to_drop = []
-            working_portfolio = portfolio.copy()
-            working_portfolio = working_portfolio[working_portfolio['Stack'] == team].sort_values(by='median', ascending = False)
-            working_portfolio = working_portfolio.reset_index(drop=True)
-            curr_own_type_max = working_portfolio.loc[0, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[0, 'Similarity Score'])
-
-            for i in range(1, len(working_portfolio)):
-                if working_portfolio.loc[i, 'Similarity Score'] > curr_own_type_max:
-                    rows_to_drop.append(i)
-                else:
-                    curr_own_type_max = working_portfolio.loc[i, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[i, 'Similarity Score'])
-            
-            working_portfolio = working_portfolio.drop(rows_to_drop).reset_index(drop=True)
-            init_portfolio = pd.concat([init_portfolio, working_portfolio])
-
-        if len(init_portfolio) >= lineup_target:
-            init_portfolio.sort_values(by='median', ascending=True).head(lineup_target)
-    
-    player_list = set()
-    player_stats = []
-    for cols in init_portfolio.columns:
-        if cols not in excluded_cols:
-            player_list.update(init_portfolio[cols].unique())
-    
-    for player in player_list:
-        # Select only the columns that are NOT in excluded_cols
-        player_cols = [col for col in init_portfolio.columns if col not in excluded_cols]
-        player_mask = init_portfolio[player_cols].apply(
-            lambda row: player in list(row), axis=1
-        )
-        
-        if player_mask.any():
-            player_stats.append({
-                'Player': player,
-                'Lineup Count': player_mask.sum(),
-                'Exposure': player_mask.sum() / len(init_portfolio)
-            })
-
-    player_summary = pd.DataFrame(player_stats)
-    print(player_summary.sort_values('Lineup Count', ascending=False).head(10))
-    player_remove_list = player_summary.sort_values('Lineup Count', ascending=False).head(5)['Player'].tolist()
-
-    for slack_var in range(1, 20):
-        concat_portfolio = pd.DataFrame(columns=portfolio.columns)
-
-        for player_out in player_remove_list:
-            rows_to_drop = []
-            working_portfolio = portfolio.copy()
-            remove_mask = working_portfolio[player_columns].apply(
-                lambda row: player_out not in list(row), axis=1
-            )
-            working_portfolio = working_portfolio[remove_mask]
-            print(working_portfolio.head(10))
-            working_portfolio = working_portfolio.sort_values(by='median', ascending=False).reset_index(drop=True)
-            curr_own_type_max = working_portfolio.loc[0, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[0, 'Similarity Score'])
-
-            for i in range(1, len(working_portfolio)):
-                if working_portfolio.loc[i, 'Similarity Score'] > curr_own_type_max:
-                    rows_to_drop.append(i)
-                else:
-                    curr_own_type_max = working_portfolio.loc[i, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[i, 'Similarity Score'])
-            
-            working_portfolio = working_portfolio.drop(rows_to_drop).reset_index(drop=True)
-            concat_portfolio = pd.concat([concat_portfolio, working_portfolio.head(math.ceil(lineup_target / 5))])
-
-        if len(concat_portfolio) >= lineup_target:
-            return concat_portfolio.sort_values(by='median', ascending=False).head(lineup_target)
-
-    return concat_portfolio.sort_values(by='median', ascending=False)

global_func/hedging_preset.py

@@ -0,0 +1,37 @@
+import pandas as pd
+import math
+from small_field_preset import small_field_preset
+from large_field_preset import large_field_preset
+
+def hedging_preset(portfolio: pd.DataFrame, lineup_target: int, projections_file: pd.DataFrame):
+    
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
+
+    check_own_df = projections_file.copy()
+    check_own_df = check_own_df.sort_values(by='Own', ascending=False)
+    top_owned = check_own_df['player_names'].head(3).tolist()
+
+    concat_portfolio = pd.DataFrame(columns=portfolio.columns)
+
+    for players in top_owned:
+        working_df = portfolio.copy()
+
+        # Create mask for lineups that contain any of the removed players
+        player_columns = [col for col in working_df.columns if col not in excluded_cols]
+
+        remove_mask = working_df[player_columns].apply(
+            lambda row: not any(player in list(row) for player in players), axis=1
+        )
+        lock_mask = working_df[player_columns].apply(
+            lambda row: all(player in list(row) for player in players), axis=1
+        )
+
+        removed_df = working_df[remove_mask]
+        locked_df = working_df[lock_mask]
+
+        removed_lineups = small_field_preset(removed_df, math.ceil(lineup_target / 2), excluded_cols)
+        locked_lineups = large_field_preset(locked_df, math.ceil(lineup_target / 2), excluded_cols)
+
+        concat_portfolio = pd.concat([concat_portfolio, removed_lineups, locked_lineups])
+
+    return concat_portfolio.sort_values(by='median', ascending=False).head(lineup_target)

global_func/large_field_preset.py

@@ -1,6 +1,9 @@
 import pandas as pd
 
 def large_field_preset(portfolio: pd.DataFrame, lineup_target: int, exclude_cols: list):
+
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
+    player_columns = [col for col in portfolio.columns if col not in excluded_cols]
     
     for slack_var in range(1, 20):
         concat_portfolio = pd.DataFrame(columns=portfolio.columns)

global_func/small_field_preset.py

@@ -2,6 +2,9 @@ import pandas as pd
 
 def small_field_preset(portfolio: pd.DataFrame, lineup_target: int, exclude_cols: list):
 
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
+    player_columns = [col for col in portfolio.columns if col not in excluded_cols]
+
     for slack_var in range(1, 20):
         concat_portfolio = pd.DataFrame(columns=portfolio.columns)