Add exposure management feature in app.py and implement exposure_spread function

- Introduced a new exposure management section in the app interface, allowing users to set target exposure for specific players.
- Added the exposure_spread function to adjust player exposure in lineups based on user-defined targets, enhancing lineup optimization.
- Updated session state handling to ensure proper data flow and management during exposure adjustments.

app.py

@@ -25,6 +25,7 @@ from global_func.volatility_preset import volatility_preset
 from global_func.reduce_volatility_preset import reduce_volatility_preset
 from global_func.analyze_player_combos import analyze_player_combos
 from global_func.stratification_function import stratification_function
+from global_func.exposure_spread import exposure_spread
 
 freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
 stacking_sports = ['MLB', 'NHL', 'NFL']
@@ -1147,6 +1148,17 @@ with tab2:
                         parsed_frame = stratification_function(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var, sorting_choice)
                         st.session_state['working_frame'] = parsed_frame.reset_index(drop=True)
                         st.session_state['export_merge'] = st.session_state['working_frame'].copy()
+            with st.expander('Exposure Management'):
+                with st.form(key='Exposures'):
+                    exposure_player = st.selectbox("Player", options=sorted(list(player_names)), default=[])
+                    exposure_target = st.number_input("Target Exposure", value=.25, min_value=0.0, max_value=1.0, step=0.01)
+                    exposure_stack_bool = st.selectbox("Maintain Stacks?", options=['Yes', 'No'], index=0)
+                    submitted = st.form_submit_button("Submit")
+                    if submitted:
+                        st.session_state['settings_base'] = False
+                        parsed_frame = exposure_spread(st.session_state['working_frame'], exposure_player, exposure_target, exposure_stack_bool, 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()
         with st.container():
             if 'export_base' not in st.session_state:
                     st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns)

global_func/exposure_spread.py

@@ -0,0 +1,44 @@
+import random
+
+#### Goal is to choose a player and adjust the amount of lineups that have them
+#### First thing you need to do is find comparable players in the projections, so any player in the projections that is within $500 of the player and within 10% of the projection
+#### Take that list of players and create a list that can be accessed for random insertion into the portfolio
+#### Find the player and the amount of rows that contain them and then find an exposure rate which is the percentage of total rows
+#### Use the exposure target argument and try to replace the player from as many rows as necessary to be at or just under the target
+
+def exposure_spread(working_frame, exposure_player, exposure_target, exposure_stack_bool, projections_df):
+    # Find comparable players in the projections
+    comparable_players = projections_df[projections_df['player_names'] == exposure_player]
+    comp_salary_high = comparable_players['salary']
+    comp_salary_low = comparable_players['salary'] - 500
+    comp_projection_high = comparable_players['Projection']
+    comp_projection_low = comparable_players['Projection'] - (comparable_players['Projection'] * .9)
+
+    comparable_players = projections_df[
+        (projections_df['salary'] >= comp_salary_low) &
+        (projections_df['salary'] <= comp_salary_high) &
+        (projections_df['Projection'] >= comp_projection_low) &
+        (projections_df['Projection'] <= comp_projection_high)
+    ]
+    
+    # Create a list of comparable players
+    comparable_player_list = comparable_players['Name'].tolist()
+
+    # find the exposure rate of the player in the working frame
+    player_mask = working_frame[working_frame.columns].apply(
+                                    lambda row: exposure_player in list(row), axis=1
+                                )
+    player_exposure = player_mask.sum() / len(working_frame)
+
+    # find the number of lineups that need to be removed to reach the target exposure
+    lineups_to_remove = (player_exposure - exposure_target) * len(working_frame)
+
+    # isolate the rows that contain the player
+    player_rows = working_frame[player_mask]
+
+    # for each row, replace with random choice from comparable player list
+    for row in player_rows.index:
+        working_frame.at[row, 'player_names'] = random.choice(comparable_player_list)
+
+    return working_frame
+