Enhance portfolio filtering and trimming options in app.py: introduce expandable sections for filter and trimming options, update portfolio trimming logic to support geomean calculations, and improve export functionality with stack count adjustments.

app.py

@@ -780,132 +780,133 @@ with tab3:
             )
 
         col1, col2 = st.columns([1, 10])
-        if st.button('Trim Portfolio'):
-            st.session_state['portfolio'] = trim_portfolio(st.session_state['portfolio'], 'median', 'Own')
         with col1:
-            with st.form(key='filter_form'):
-                max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, step=1)
-                min_salary = st.number_input("Min acceptable salary?", value=1000, min_value=1000, step=100)
-                max_salary = st.number_input("Max acceptable salary?", value=60000, min_value=1000, step=100)
-                max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=.50, min_value=0.005, step=.001)
-                min_lineup_edge = st.number_input("Min acceptable Lineup Edge?", value=-.5, min_value=-1.00, step=.001)
-                player_names = set()
-                for col in st.session_state['portfolio'].columns:
-                    if col not in excluded_cols:
-                        player_names.update(st.session_state['portfolio'][col].unique())
-                player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[])
-                player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[])
-                if stack_dict is not None:
-                    stack_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_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[])
-
-                st.session_state['math_done'] = False
-                submitted = st.form_submit_button("Submit")
+            with st.expander('Filter Options'):
+                with st.form(key='filter_form'):
+                    max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, step=1)
+                    min_salary = st.number_input("Min acceptable salary?", value=1000, min_value=1000, step=100)
+                    max_salary = st.number_input("Max acceptable salary?", value=60000, min_value=1000, step=100)
+                    max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=.50, min_value=0.005, step=.001)
+                    min_lineup_edge = st.number_input("Min acceptable Lineup Edge?", value=-.5, min_value=-1.00, step=.001)
+                    player_names = set()
+                    for col in st.session_state['portfolio'].columns:
+                        if col not in excluded_cols:
+                            player_names.update(st.session_state['portfolio'][col].unique())
+                    player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[])
+                    player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[])
+                    if stack_dict is not None:
+                        stack_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_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[])
+                    
+                    submitted = st.form_submit_button("Submit")
+            with st.expander('Trimming Options'):
+                performance_type = st.selectbox("Select sort type", ['median', 'Finish_percentile'])
+                own_type = st.selectbox("Select trimming variable type", ['Own', 'Geomean'])
+                if st.button('Trim Portfolio'):
+                    st.session_state['portfolio'] = trim_portfolio(st.session_state['portfolio'], performance_type, own_type)
 
         with col2:
-            if 'math_done' not in st.session_state or st.session_state['math_done'] == False:
-                st.session_state['portfolio'] = predict_dupes(st.session_state['portfolio'], map_dict, site_var, type_var, Contest_Size, strength_var)
-                st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Dupes'] <= max_dupes]
-                st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] >= min_salary]
-                st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] <= max_salary]
-                st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Finish_percentile'] <= max_finish_percentile]
-                st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Lineup Edge'] >= min_lineup_edge]
-                if stack_dict is not None:
-                    if stack_toggle == 'All Stacks':
-                        st.session_state['portfolio'] = st.session_state['portfolio']
-                        st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-                    else:
-                        st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Stack'].isin(stack_selections)]
-                        st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-                if player_remove:
-                    # Create mask for lineups that contain any of the removed players
-                    player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                    remove_mask = st.session_state['portfolio'][player_columns].apply(
-                        lambda row: not any(player in list(row) for player in player_remove), axis=1
-                    )
-                    st.session_state['portfolio'] = st.session_state['portfolio'][remove_mask]
+            st.session_state['portfolio'] = predict_dupes(st.session_state['portfolio'], map_dict, site_var, type_var, Contest_Size, strength_var)
+            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Dupes'] <= max_dupes]
+            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] >= min_salary]
+            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] <= max_salary]
+            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Finish_percentile'] <= max_finish_percentile]
+            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Lineup Edge'] >= min_lineup_edge]
+            if stack_dict is not None:
+                if stack_toggle == 'All Stacks':
+                    st.session_state['portfolio'] = st.session_state['portfolio']
+                    st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
+                else:
+                    st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Stack'].isin(stack_selections)]
+                    st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
+            if player_remove:
+                # Create mask for lineups that contain any of the removed players
+                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
+                remove_mask = st.session_state['portfolio'][player_columns].apply(
+                    lambda row: not any(player in list(row) for player in player_remove), axis=1
+                )
+                st.session_state['portfolio'] = st.session_state['portfolio'][remove_mask]
+            
+            if player_lock:
+                # Create mask for lineups that contain all locked players
+                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
                 
-                if player_lock:
-                    # Create mask for lineups that contain all locked players
-                    player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                    
-                    lock_mask = st.session_state['portfolio'][player_columns].apply(
-                        lambda row: all(player in list(row) for player in player_lock), axis=1
-                    )
-                    st.session_state['portfolio'] = st.session_state['portfolio'][lock_mask]
-                export_file = st.session_state['portfolio'].copy()
-                st.session_state['portfolio'] = st.session_state['portfolio'].sort_values(by='median', ascending=False)
-                if csv_file is not None:
-                    player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                    for col in player_columns:
-                        export_file[col] = export_file[col].map(st.session_state['export_dict'])
-                with st.expander("Download options"):
-                    if stack_dict is not None:
-                        with st.form(key='stack_form'):
-                            st.subheader("Stack Count Adjustments")
-                            st.info("This allows you to fine tune the stacks that you wish to export. If you want to make sure you don't export any of a specific stack you can 0 it out.")
-                            # Create a container for stack value inputs
-                            sort_container = st.container()
-                            with sort_container:
-                                sort_var = st.selectbox("Sort export portfolio by:", options=['median', 'Lineup Edge', 'Own'])
-                            
-                            # Get unique stack values
-                            unique_stacks = sorted(list(set(stack_dict.values())))
-                            
-                            # Create a dictionary to store stack multipliers
-                            if 'stack_multipliers' not in st.session_state:
-                                st.session_state.stack_multipliers = {stack: 0.0 for stack in unique_stacks}
-                            
-                            # Create columns for the stack inputs
-                            num_cols = 6  # Number of columns to display
-                            for i in range(0, len(unique_stacks), num_cols):
-                                cols = st.columns(num_cols)
-                                for j, stack in enumerate(unique_stacks[i:i+num_cols]):
-                                    with cols[j]:
-                                        # Create a unique key for each number input
-                                        key = f"stack_count_{stack}"
-                                        # Get the current count of this stack in the portfolio
-                                        current_stack_count = len(st.session_state['portfolio'][st.session_state['portfolio']['Stack'] == stack])
-                                        # Create number input with current value and max value based on actual count
-                                        st.session_state.stack_multipliers[stack] = st.number_input(
-                                            f"{stack} count",
-                                            min_value=0.0,
-                                            max_value=float(current_stack_count),
-                                            value=0.0,
-                                            step=1.0,
-                                            key=key
-                                        )
-                            
-                            # Create a copy of the portfolio
-                            portfolio_copy = st.session_state['portfolio'].copy()
-                            
-                            # Create a list to store selected rows
-                            selected_rows = []
-                            
-                            # For each stack, select the top N rows based on the count value
-                            for stack in unique_stacks:
-                                if stack in st.session_state.stack_multipliers:
-                                    count = int(st.session_state.stack_multipliers[stack])
-                                    # Get rows for this stack
-                                    stack_rows = portfolio_copy[portfolio_copy['Stack'] == stack]
-                                    # Sort by median and take top N rows
-                                    top_rows = stack_rows.nlargest(count, sort_var)
-                                    selected_rows.append(top_rows)
-                            
-                            # Combine all selected rows
-                            portfolio_copy = pd.concat(selected_rows)
-                            
-                            # Update export_file with filtered data
-                            export_file = portfolio_copy.copy()
-                            for col in export_file.columns:
-                                if col not in excluded_cols:
-                                    export_file[col] = export_file[col].map(st.session_state['export_dict'])
-                            
-                            submitted = st.form_submit_button("Submit")
-                            if submitted:
-                                st.write('Export portfolio updated!')
-                st.session_state['math_done'] = True
+                lock_mask = st.session_state['portfolio'][player_columns].apply(
+                    lambda row: all(player in list(row) for player in player_lock), axis=1
+                )
+                st.session_state['portfolio'] = st.session_state['portfolio'][lock_mask]
+            export_file = st.session_state['portfolio'].copy()
+            st.session_state['portfolio'] = st.session_state['portfolio'].sort_values(by='median', ascending=False)
+            if csv_file is not None:
+                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
+                for col in player_columns:
+                    export_file[col] = export_file[col].map(st.session_state['export_dict'])
+            with st.expander("Download options"):
+                if stack_dict is not None:
+                    with st.form(key='stack_form'):
+                        st.subheader("Stack Count Adjustments")
+                        st.info("This allows you to fine tune the stacks that you wish to export. If you want to make sure you don't export any of a specific stack you can 0 it out.")
+                        # Create a container for stack value inputs
+                        sort_container = st.container()
+                        with sort_container:
+                            sort_var = st.selectbox("Sort export portfolio by:", options=['median', 'Lineup Edge', 'Own'])
+                        
+                        # Get unique stack values
+                        unique_stacks = sorted(list(set(stack_dict.values())))
+                        
+                        # Create a dictionary to store stack multipliers
+                        if 'stack_multipliers' not in st.session_state:
+                            st.session_state.stack_multipliers = {stack: 0.0 for stack in unique_stacks}
+                        
+                        # Create columns for the stack inputs
+                        num_cols = 6  # Number of columns to display
+                        for i in range(0, len(unique_stacks), num_cols):
+                            cols = st.columns(num_cols)
+                            for j, stack in enumerate(unique_stacks[i:i+num_cols]):
+                                with cols[j]:
+                                    # Create a unique key for each number input
+                                    key = f"stack_count_{stack}"
+                                    # Get the current count of this stack in the portfolio
+                                    current_stack_count = len(st.session_state['portfolio'][st.session_state['portfolio']['Stack'] == stack])
+                                    # Create number input with current value and max value based on actual count
+                                    st.session_state.stack_multipliers[stack] = st.number_input(
+                                        f"{stack} count",
+                                        min_value=0.0,
+                                        max_value=float(current_stack_count),
+                                        value=0.0,
+                                        step=1.0,
+                                        key=key
+                                    )
+                        
+                        # Create a copy of the portfolio
+                        portfolio_copy = st.session_state['portfolio'].copy()
+                        
+                        # Create a list to store selected rows
+                        selected_rows = []
+                        
+                        # For each stack, select the top N rows based on the count value
+                        for stack in unique_stacks:
+                            if stack in st.session_state.stack_multipliers:
+                                count = int(st.session_state.stack_multipliers[stack])
+                                # Get rows for this stack
+                                stack_rows = portfolio_copy[portfolio_copy['Stack'] == stack]
+                                # Sort by median and take top N rows
+                                top_rows = stack_rows.nlargest(count, sort_var)
+                                selected_rows.append(top_rows)
+                        
+                        # Combine all selected rows
+                        portfolio_copy = pd.concat(selected_rows)
+                        
+                        # Update export_file with filtered data
+                        export_file = portfolio_copy.copy()
+                        for col in export_file.columns:
+                            if col not in excluded_cols:
+                                export_file[col] = export_file[col].map(st.session_state['export_dict'])
+                        
+                        submitted = st.form_submit_button("Submit")
+                        if submitted:
+                            st.write('Export portfolio updated!')
                 
             st.download_button(label="Download Portfolio", data=export_file.to_csv(index=False), file_name="portfolio.csv", mime="text/csv")
             

global_func/predict_dupes.py

@@ -3,6 +3,7 @@ import numpy as np
 import pandas as pd
 import time
 from fuzzywuzzy import process
+from scipy.stats import gmean
 
 def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, strength_var):
     if strength_var == 'Weak':
@@ -181,7 +182,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
     portfolio['Lineup Edge'] = portfolio['Win%'] * ((.5 - portfolio['Finish_percentile']) * (Contest_Size / 2.5))
     portfolio['Lineup Edge'] = portfolio.apply(lambda row: row['Lineup Edge'] / (row['Dupes'] + 1) if row['Dupes'] > 0 else row['Lineup Edge'], axis=1)
     portfolio['Lineup Edge'] = portfolio['Lineup Edge'] - portfolio['Lineup Edge'].mean()
-    portfolio['Product Own'] = portfolio[own_columns].product(axis=1)
+    portfolio['Geomean'] = portfolio[own_columns].apply(lambda row: gmean(row), axis=1)
     portfolio = portfolio.drop(columns=dup_count_columns)
     portfolio = portfolio.drop(columns=own_columns)
     portfolio = portfolio.drop(columns=calc_columns)

global_func/trim_portfolio.py

@@ -1,5 +1,8 @@
 def trim_portfolio(portfolio, performance_type, own_type):
-    working_portfolio = portfolio.sort_values(by=performance_type, ascending = False).reset_index(drop=True)
+    if performance_type == 'Finish_percentile':
+        working_portfolio = portfolio.sort_values(by=performance_type, ascending = True).reset_index(drop=True)
+    else:
+        working_portfolio = portfolio.sort_values(by=performance_type, ascending = False).reset_index(drop=True)
     rows_to_drop = []
     curr_own_type_max = working_portfolio.loc[0, own_type]