Add stratification functionality and enhance portfolio handling in app.py

- Introduced a new stratification_function to allow users to generate lineups based on target similarity scores, enhancing lineup optimization capabilities.
- Updated app.py to integrate the new stratification feature, including user interface elements for selecting sorting criteria and lineup targets.
- Improved portfolio handling by converting the portfolio to a parquet format for better performance and memory efficiency.
- Enhanced data processing by ensuring the correct mapping of stack and size information from the portfolio, improving the accuracy of lineup analysis.

app.py

@@ -4,6 +4,7 @@ import pandas as pd
 from rapidfuzz import process
 import random
 from collections import Counter
+import io
 
 ## import global functions
 from global_func.clean_player_name import clean_player_name
@@ -23,6 +24,7 @@ from global_func.hedging_preset import hedging_preset
 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
 
 freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
 stacking_sports = ['MLB', 'NHL', 'NFL']
@@ -128,6 +130,7 @@ with tab1:
                 else:
                     stack_dict = None
                 if st.session_state['portfolio'] is not None:
+                    
                     st.success('Portfolio file loaded successfully!')
                     st.session_state['portfolio'] = st.session_state['portfolio'].apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
                     st.dataframe(st.session_state['portfolio'].head(10))
@@ -180,9 +183,10 @@ with tab1:
                             
                 projections = projections.apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
                 st.dataframe(projections.head(10))
-    
+
     if portfolio_file and projections_file:
         if st.session_state['portfolio'] is not None and projections is not None:
+        
             st.subheader("Name Matching Analysis")
             # Initialize projections_df in session state if it doesn't exist
             # Get unique names from portfolio
@@ -281,15 +285,82 @@ with tab1:
                     ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[2:]) else 0,
                     axis=1
                 )
-                stack_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack']))
-                size_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Size']))
+                st.session_state['stack_dict'] = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack']))
+                st.session_state['size_dict'] = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Size']))
 
-            working_frame = st.session_state['portfolio'].copy()
             try:
                 st.session_state['export_dict'] = dict(zip(st.session_state['csv_file']['Name'], st.session_state['csv_file']['Name + ID']))
             except:
                 st.session_state['export_dict'] = dict(zip(st.session_state['csv_file']['Nickname'], st.session_state['csv_file']['Id']))
+            if 'map_dict' not in st.session_state:
+                if site_var == 'Draftkings':
+                    if type_var == 'Classic':
+                        if sport_var == 'CS2':
+                            st.session_state['map_dict'] = {
+                                'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
+                                'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
+                                'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                                'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                                'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
+                                'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
+                                'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
+                                'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
+                                'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
+                            }
+                        elif sport_var != 'CS2':
+                            st.session_state['map_dict'] = {
+                                'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
+                                'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
+                                'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                                'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                                'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
+                                'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
+                                'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                                'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
+                                'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
+                            }
+                    elif type_var == 'Showdown':
+                        if sport_var == 'GOLF':
+                            st.session_state['map_dict'] = {
+                                'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
+                                'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
+                                'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                                'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                                'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
+                                'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
+                                'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                                'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                                'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership']))
+                            }
+                        if sport_var != 'GOLF':
+                            st.session_state['map_dict'] = {
+                                'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
+                                'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
+                                'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                                'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                                'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
+                                'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
+                                'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
+                                'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
+                                'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
+                            }
+                elif site_var == 'Fanduel':
+                    st.session_state['map_dict'] = {
+                        'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
+                        'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
+                        'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                        'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                        'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
+                        'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
+                        'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                        'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
+                        'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
+                    }
             st.session_state['origin_portfolio'] = st.session_state['portfolio'].copy()
+            buffer = io.BytesIO()
+            st.session_state['portfolio'].to_parquet(buffer, compression='snappy')
+            st.session_state['origin_portfolio'] = buffer.getvalue()
+            del st.session_state['portfolio']
 
 # with tab2:
 #     if st.button('Clear data', key='reset2'):
@@ -804,7 +875,7 @@ with tab1:
 #             )
 
 with tab2:
-    if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
+    if 'origin_portfolio' in st.session_state and 'projections_df' in st.session_state:
         with st.container():
             col1, col2 = st.columns(2)
             with col1:
@@ -828,70 +899,8 @@ with tab2:
 
         if 'working_frame' not in st.session_state:
             st.session_state['settings_base'] = True
-            st.session_state['working_frame'] = st.session_state['origin_portfolio'].copy()
-            if site_var == 'Draftkings':
-                if type_var == 'Classic':
-                    if sport_var == 'CS2':
-                        st.session_state['map_dict'] = {
-                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
-                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
-                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-                        }
-                    elif sport_var != 'CS2':
-                        st.session_state['map_dict'] = {
-                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
-                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-                        }
-                elif type_var == 'Showdown':
-                    if sport_var == 'GOLF':
-                        st.session_state['map_dict'] = {
-                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
-                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership']))
-                        }
-                    if sport_var != 'GOLF':
-                        st.session_state['map_dict'] = {
-                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
-                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
-                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-                        }
-            elif site_var == 'Fanduel':
-                st.session_state['map_dict'] = {
-                    'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                    'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                    'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                    'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                    'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
-                    'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                    'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                    'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                    'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-                }
+            st.session_state['working_frame'] = pd.read_parquet(io.BytesIO(st.session_state['origin_portfolio']))
+            
             if type_var == 'Classic':
                 if sport_var == 'CS2':
                     # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
@@ -919,9 +928,9 @@ with tab2:
                     st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1)
                     st.session_state['working_frame']['median'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1)
                     st.session_state['working_frame']['Own'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1)
-                    if stack_dict is not None:
-                        st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(stack_dict)
-                        st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(size_dict)
+                    if 'stack_dict' in st.session_state:
+                        st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(st.session_state['stack_dict'])
+                        st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(st.session_state['size_dict'])
             elif type_var == 'Showdown':
                 # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
                 st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(
@@ -943,20 +952,14 @@ with tab2:
                             sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
                     axis=1
                 )
+            st.session_state['working_frame']['Own'] = st.session_state['working_frame']['Own'].astype('float32')
+            st.session_state['working_frame']['median'] = st.session_state['working_frame']['median'].astype('float32')
+            st.session_state['working_frame']['salary'] = st.session_state['working_frame']['salary'].astype('uint16')
+            
             st.session_state['base_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var)
             st.session_state['working_frame'] = st.session_state['base_frame'].copy()
             # st.session_state['highest_owned_teams'] = st.session_state['projections_df'][~st.session_state['projections_df']['position'].isin(['P', 'SP'])].groupby('team')['ownership'].sum().sort_values(ascending=False).head(3).index.tolist()
             # st.session_state['highest_owned_pitchers'] = st.session_state['projections_df'][st.session_state['projections_df']['position'].isin(['P', 'SP'])]['player_names'].sort_values(by='ownership', ascending=False).head(3).tolist()
-            if 'info_columns_dict' not in st.session_state:
-                st.session_state['info_columns_dict'] = {
-                    'Dupes': st.session_state['working_frame']['Dupes'],
-                    'Finish_percentile': st.session_state['working_frame']['Finish_percentile'],
-                    'Win%': st.session_state['working_frame']['Win%'],
-                    'Lineup Edge': st.session_state['working_frame']['Lineup Edge'],
-                    'Weighted Own': st.session_state['working_frame']['Weighted Own'],
-                    'Geomean': st.session_state['working_frame']['Geomean'],
-                    'Diversity': st.session_state['working_frame']['Diversity']
-                }
 
             if 'trimming_dict_maxes' not in st.session_state:
                 st.session_state['trimming_dict_maxes'] = {
@@ -987,10 +990,10 @@ with tab2:
                     min_lineup_edge = st.number_input("Min acceptable Lineup Edge?", value=-.5, min_value=-1.00, step=.001)
                     if sport_var in ['NFL', 'MLB', 'NHL']:
                         stack_include_toggle = st.selectbox("Include specific stacks?", options=['All Stacks', 'Specific Stacks'], index=0)
-                        stack_selections = st.multiselect("If Specific Stacks, Which to include?", options=sorted(list(set(stack_dict.values()))), default=[])
+                        stack_selections = st.multiselect("If Specific Stacks, Which to include?", options=sorted(list(set(st.session_state['stack_dict'].values()))), default=[])
 
                         stack_remove_toggle = st.selectbox("Remove specific stacks?", options=['No', 'Yes'], index=0)
-                        stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[])
+                        stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(st.session_state['stack_dict'].values()))), default=[])
                     
                     submitted = st.form_submit_button("Submit")
                     
@@ -1096,14 +1099,14 @@ with tab2:
                     with min_sort:
                         performance_threshold_low = st.number_input("Min", value=0.0, min_value=0.0, step=1.0, key='min_sort')
                     with max_sort:
-                        performance_threshold_high = st.number_input("Max", value=st.session_state['trimming_dict_maxes'][performance_type], min_value=0.0, step=1.0, key='max_sort')
+                        performance_threshold_high = st.number_input("Max", value=float(st.session_state['trimming_dict_maxes'][performance_type]), min_value=0.0, step=1.0, key='max_sort')
                     
                     st.write("Trimming threshold range:")
                     min_trim, max_trim = st.columns(2)
                     with min_trim:
                         own_threshold_low = st.number_input("Min", value=0.0, min_value=0.0, step=1.0, key='min_trim')
                     with max_trim:
-                        own_threshold_high = st.number_input("Max", value=st.session_state['trimming_dict_maxes'][own_type], min_value=0.0, step=1.0, key='max_trim')
+                        own_threshold_high = st.number_input("Max", value=float(st.session_state['trimming_dict_maxes'][own_type]), min_value=0.0, step=1.0, key='max_trim')
                     
                     submitted = st.form_submit_button("Trim")
                     if submitted:
@@ -1134,7 +1137,16 @@ with tab2:
                             parsed_frame = reduce_volatility_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var)
                         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('Stratify'):
+                with st.form(key='Stratification'):
+                    sorting_choice = st.selectbox("Stat Choice", options=['median', 'Own', 'Weighted Own', 'Geomean', 'Lineup Edge', 'Finish_percentile', 'Diversity'], 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:
+                        st.session_state['settings_base'] = False
+                        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.container():
             if 'export_base' not in st.session_state:
                     st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns)
@@ -1180,7 +1192,7 @@ with tab2:
                             display_frame = st.session_state['export_base']
 
             total_rows = len(display_frame)
-            rows_per_page = 500
+            rows_per_page = 100
             total_pages = (total_rows + rows_per_page - 1) // rows_per_page  # Ceiling division
 
             # Initialize page number in session state if not exists
@@ -1243,49 +1255,14 @@ with tab2:
             )
         player_stats_col, stack_stats_col, combos_col = st.tabs(['Player Stats', 'Stack Stats', 'Combos'])
         with player_stats_col:
-
-            player_stats = []
-            player_columns = [col for col in display_frame.columns if col not in excluded_cols]
-            
-            if st.session_state['settings_base'] and 'origin_player_exposures' in st.session_state and display_frame_source == 'Portfolio':
-                st.session_state['player_summary'] = st.session_state['origin_player_exposures']
-            else:
-                if type_var == 'Showdown':
-                    for player in player_names:
-                        # Create mask for lineups where this player is Captain (first column)
-                        cpt_mask = display_frame[player_columns[0]] == player
-                        
-                        if cpt_mask.any():
-                            player_stats.append({
-                                'Player': f"{player} (CPT)",
-                                'Lineup Count': cpt_mask.sum(),
-                                'Exposure': cpt_mask.sum() / len(display_frame),
-                                'Avg Median': display_frame[cpt_mask]['median'].mean(),
-                                'Avg Own': display_frame[cpt_mask]['Own'].mean(),
-                                'Avg Dupes': display_frame[cpt_mask]['Dupes'].mean(),
-                                'Avg Finish %': display_frame[cpt_mask]['Finish_percentile'].mean(),
-                                'Avg Lineup Edge': display_frame[cpt_mask]['Lineup Edge'].mean(),
-                            })
-                        
-                        # Create mask for lineups where this player is FLEX (other columns)
-                        flex_mask = display_frame[player_columns[1:]].apply(
-                            lambda row: player in list(row), axis=1
-                        )
-                        
-                        if flex_mask.any():
-                            player_stats.append({
-                                'Player': f"{player} (FLEX)",
-                                'Lineup Count': flex_mask.sum(),
-                                'Exposure': flex_mask.sum() / len(display_frame),
-                                'Avg Median': display_frame[flex_mask]['median'].mean(),
-                                'Avg Own': display_frame[flex_mask]['Own'].mean(),
-                                'Avg Dupes': display_frame[flex_mask]['Dupes'].mean(),
-                                'Avg Finish %': display_frame[flex_mask]['Finish_percentile'].mean(),
-                                'Avg Lineup Edge': display_frame[flex_mask]['Lineup Edge'].mean(),
-                            })
+            if st.button("Analyze Players", key='analyze_players'):
+                player_stats = []
+                player_columns = [col for col in display_frame.columns if col not in excluded_cols]
+                
+                if st.session_state['settings_base'] and 'origin_player_exposures' in st.session_state and display_frame_source == 'Portfolio':
+                    st.session_state['player_summary'] = st.session_state['origin_player_exposures']
                 else:
-                    if sport_var == 'CS2':
-                        # Handle Captain positions
+                    if type_var == 'Showdown':
                         for player in player_names:
                             # Create mask for lineups where this player is Captain (first column)
                             cpt_mask = display_frame[player_columns[0]] == player
@@ -1318,77 +1295,69 @@ with tab2:
                                     'Avg Finish %': display_frame[flex_mask]['Finish_percentile'].mean(),
                                     'Avg Lineup Edge': display_frame[flex_mask]['Lineup Edge'].mean(),
                                 })
-                    elif sport_var != 'CS2':
-                        # Original Classic format processing
-                        for player in player_names:
-                            player_mask = display_frame[player_columns].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(display_frame),
-                                    'Avg Median': display_frame[player_mask]['median'].mean(),
-                                    'Avg Own': display_frame[player_mask]['Own'].mean(),
-                                    'Avg Dupes': display_frame[player_mask]['Dupes'].mean(),
-                                    'Avg Finish %': display_frame[player_mask]['Finish_percentile'].mean(),
-                                    'Avg Lineup Edge': display_frame[player_mask]['Lineup Edge'].mean(),
-                                })
+                    else:
+                        if sport_var == 'CS2':
+                            # Handle Captain positions
+                            for player in player_names:
+                                # Create mask for lineups where this player is Captain (first column)
+                                cpt_mask = display_frame[player_columns[0]] == player
+                                
+                                if cpt_mask.any():
+                                    player_stats.append({
+                                        'Player': f"{player} (CPT)",
+                                        'Lineup Count': cpt_mask.sum(),
+                                        'Exposure': cpt_mask.sum() / len(display_frame),
+                                        'Avg Median': display_frame[cpt_mask]['median'].mean(),
+                                        'Avg Own': display_frame[cpt_mask]['Own'].mean(),
+                                        'Avg Dupes': display_frame[cpt_mask]['Dupes'].mean(),
+                                        'Avg Finish %': display_frame[cpt_mask]['Finish_percentile'].mean(),
+                                        'Avg Lineup Edge': display_frame[cpt_mask]['Lineup Edge'].mean(),
+                                    })
+                                
+                                # Create mask for lineups where this player is FLEX (other columns)
+                                flex_mask = display_frame[player_columns[1:]].apply(
+                                    lambda row: player in list(row), axis=1
+                                )
+                                
+                                if flex_mask.any():
+                                    player_stats.append({
+                                        'Player': f"{player} (FLEX)",
+                                        'Lineup Count': flex_mask.sum(),
+                                        'Exposure': flex_mask.sum() / len(display_frame),
+                                        'Avg Median': display_frame[flex_mask]['median'].mean(),
+                                        'Avg Own': display_frame[flex_mask]['Own'].mean(),
+                                        'Avg Dupes': display_frame[flex_mask]['Dupes'].mean(),
+                                        'Avg Finish %': display_frame[flex_mask]['Finish_percentile'].mean(),
+                                        'Avg Lineup Edge': display_frame[flex_mask]['Lineup Edge'].mean(),
+                                    })
+                        elif sport_var != 'CS2':
+                            # Original Classic format processing
+                            for player in player_names:
+                                player_mask = display_frame[player_columns].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(display_frame),
+                                        'Avg Median': display_frame[player_mask]['median'].mean(),
+                                        'Avg Own': display_frame[player_mask]['Own'].mean(),
+                                        'Avg Dupes': display_frame[player_mask]['Dupes'].mean(),
+                                        'Avg Finish %': display_frame[player_mask]['Finish_percentile'].mean(),
+                                        'Avg Lineup Edge': display_frame[player_mask]['Lineup Edge'].mean(),
+                                    })
+                    
+                    player_summary = pd.DataFrame(player_stats)
+                    player_summary = player_summary.sort_values('Lineup Count', ascending=False)
+                    st.session_state['player_summary'] = player_summary.copy()
+                    if 'origin_player_exposures' not in st.session_state:
+                        st.session_state['origin_player_exposures'] = player_summary.copy()
                 
-                player_summary = pd.DataFrame(player_stats)
-                player_summary = player_summary.sort_values('Lineup Count', ascending=False)
-                st.session_state['player_summary'] = player_summary.copy()
-                if 'origin_player_exposures' not in st.session_state:
-                    st.session_state['origin_player_exposures'] = player_summary.copy()
-            
-            st.subheader("Player Summary")
-            st.dataframe(
-                st.session_state['player_summary'].style
-                .background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes'])
-                .format({
-                    'Avg Median': '{:.2f}',
-                    'Avg Own': '{:.2f}',
-                    'Avg Dupes': '{:.2f}',
-                    'Avg Finish %': '{:.2%}',
-                    'Avg Lineup Edge': '{:.2%}',
-                    'Exposure': '{:.2%}'
-                }),
-                height=400,
-                use_container_width=True
-            )
-        
-        with stack_stats_col:
-            if 'Stack' in display_frame.columns:
-                stack_stats = []
-                stack_columns = [col for col in display_frame.columns if col.startswith('Stack')]
-
-                if st.session_state['settings_base'] and 'origin_stack_exposures' in st.session_state and display_frame_source == 'Portfolio':
-                    st.session_state['stack_summary'] = st.session_state['origin_stack_exposures']
-                else:
-                    for stack in stack_dict.values():
-                        stack_mask = display_frame['Stack'] == stack
-                        if stack_mask.any():
-                            stack_stats.append({
-                                'Stack': stack,
-                                'Lineup Count': stack_mask.sum(),
-                                'Exposure': stack_mask.sum() / len(display_frame),
-                                'Avg Median': display_frame[stack_mask]['median'].mean(),
-                                'Avg Own': display_frame[stack_mask]['Own'].mean(),
-                                'Avg Dupes': display_frame[stack_mask]['Dupes'].mean(),
-                                'Avg Finish %': display_frame[stack_mask]['Finish_percentile'].mean(),
-                                'Avg Lineup Edge': display_frame[stack_mask]['Lineup Edge'].mean(),
-                            })
-                    stack_summary = pd.DataFrame(stack_stats)
-                    stack_summary = stack_summary.sort_values('Lineup Count', ascending=False).drop_duplicates()
-                    st.session_state['stack_summary'] = stack_summary.copy()
-                    if 'origin_stack_exposures' not in st.session_state:
-                        st.session_state['origin_stack_exposures'] = stack_summary.copy()
-
-                st.subheader("Stack Summary")
+                st.subheader("Player Summary")
                 st.dataframe(
-                    st.session_state['stack_summary'].style
+                    st.session_state['player_summary'].style
                     .background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes'])
                     .format({
                         'Avg Median': '{:.2f}',
@@ -1401,6 +1370,50 @@ with tab2:
                     height=400,
                     use_container_width=True
                 )
+        
+        with stack_stats_col:
+            if 'Stack' in display_frame.columns:
+                if st.button("Analyze Stacks", key='analyze_stacks'):
+                    stack_stats = []
+                    stack_columns = [col for col in display_frame.columns if col.startswith('Stack')]
+
+                    if st.session_state['settings_base'] and 'origin_stack_exposures' in st.session_state and display_frame_source == 'Portfolio':
+                        st.session_state['stack_summary'] = st.session_state['origin_stack_exposures']
+                    else:
+                        for stack in st.session_state['stack_dict'].values():
+                            stack_mask = display_frame['Stack'] == stack
+                            if stack_mask.any():
+                                stack_stats.append({
+                                    'Stack': stack,
+                                    'Lineup Count': stack_mask.sum(),
+                                    'Exposure': stack_mask.sum() / len(display_frame),
+                                    'Avg Median': display_frame[stack_mask]['median'].mean(),
+                                    'Avg Own': display_frame[stack_mask]['Own'].mean(),
+                                    'Avg Dupes': display_frame[stack_mask]['Dupes'].mean(),
+                                    'Avg Finish %': display_frame[stack_mask]['Finish_percentile'].mean(),
+                                    'Avg Lineup Edge': display_frame[stack_mask]['Lineup Edge'].mean(),
+                                })
+                        stack_summary = pd.DataFrame(stack_stats)
+                        stack_summary = stack_summary.sort_values('Lineup Count', ascending=False).drop_duplicates()
+                        st.session_state['stack_summary'] = stack_summary.copy()
+                        if 'origin_stack_exposures' not in st.session_state:
+                            st.session_state['origin_stack_exposures'] = stack_summary.copy()
+
+                    st.subheader("Stack Summary")
+                    st.dataframe(
+                        st.session_state['stack_summary'].style
+                        .background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes'])
+                        .format({
+                            'Avg Median': '{:.2f}',
+                            'Avg Own': '{:.2f}',
+                            'Avg Dupes': '{:.2f}',
+                            'Avg Finish %': '{:.2%}',
+                            'Avg Lineup Edge': '{:.2%}',
+                            'Exposure': '{:.2%}'
+                        }),
+                        height=400,
+                        use_container_width=True
+                    )
             else:
                 stack_summary = pd.DataFrame(columns=['Stack', 'Lineup Count', 'Avg Median', 'Avg Own', 'Avg Dupes', 'Avg Finish %', 'Avg Lineup Edge'])
             

global_func/stratification_function.py

@@ -0,0 +1,32 @@
+import pandas as pd
+import numpy as np
+
+def stratification_function(portfolio: pd.DataFrame, lineup_target: int, exclude_cols: list, sport: str, sorting_choice: str):
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
+    player_columns = [col for col in portfolio.columns if col not in excluded_cols]
+    
+    concat_portfolio = portfolio.copy()
+    if sorting_choice == 'Finish_percentile':
+        concat_portfolio = concat_portfolio.sort_values(by=sorting_choice, ascending=True).reset_index(drop=True)
+    else:
+        concat_portfolio = concat_portfolio.sort_values(by=sorting_choice, ascending=False).reset_index(drop=True)
+
+    # Calculate target similarity scores for linear progression
+    similarity_floor = concat_portfolio[sorting_choice].min()
+    similarity_ceiling = concat_portfolio[sorting_choice].max()
+    
+    # Create evenly spaced target similarity scores
+    target_similarities = np.linspace(similarity_floor, similarity_ceiling, lineup_target)
+    
+    # Find the closest lineup to each target similarity score
+    selected_indices = []
+    for target_sim in target_similarities:
+        # Find the index of the closest similarity score
+        closest_idx = (concat_portfolio[sorting_choice] - target_sim).abs().idxmin()
+        if closest_idx not in selected_indices:  # Avoid duplicates
+            selected_indices.append(closest_idx)
+    
+    # Select the lineups
+    concat_portfolio = concat_portfolio.loc[selected_indices].reset_index(drop=True)
+    
+    return concat_portfolio.sort_values(by=sorting_choice, ascending=False)