Add reassess_edge function in reassess_edge.py for recalculating lineup metrics based on player performance, and update app.py to utilize this function for improved edge assessments in player lineups.

app.py

@@ -26,6 +26,7 @@ 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
+from global_func.reassess_edge import reassess_edge
 
 freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
 stacking_sports = ['MLB', 'NHL', 'NFL', 'LOL']
@@ -1526,7 +1527,7 @@ with tab2:
                         st.session_state['export_base']['salary'] = st.session_state['export_base']['salary'].astype('uint16')
                         
                         print(st.session_state['export_base'].head(10))
-                        st.session_state['export_base'] = predict_dupes(st.session_state['export_base'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var)
+                        st.session_state['export_base'] = reassess_edge(st.session_state['export_base'], st.session_state['export_base'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)
                         st.session_state['export_merge'] = st.session_state['export_base'].copy()
                         
         with st.container():

global_func/reassess_edge.py

@@ -9,9 +9,62 @@ import pandas as pd
 import numpy as np
 import math
 
+def calculate_weighted_ownership_vectorized(ownership_array):
+    """
+    Vectorized version of calculate_weighted_ownership using NumPy operations.
+    
+    Args:
+        ownership_array: 2D array of ownership values (rows x players)
+        
+    Returns:
+        array: Calculated weighted ownership values for each row
+    """
+    # Convert percentages to decimals and handle NaN values
+    ownership_array = np.where(np.isnan(ownership_array), 0, ownership_array) / 100
+    
+    # Calculate row means
+    row_means = np.mean(ownership_array, axis=1, keepdims=True)
+    
+    # Calculate average of each value with the overall mean
+    value_means = (ownership_array + row_means) / 2
+    
+    # Take average of all those means
+    avg_of_means = np.mean(value_means, axis=1)
+    
+    # Multiply by count of values
+    weighted = avg_of_means * ownership_array.shape[1]
+    
+    # Subtract (max - min) for each row
+    row_max = np.max(ownership_array, axis=1)
+    row_min = np.min(ownership_array, axis=1)
+    weighted = weighted - (row_max - row_min)
+    
+    # Convert back to percentage form
+    return weighted * 10000
+
+def calculate_weighted_ownership_wrapper(row_ownerships):
+    """
+    Wrapper function for the original calculate_weighted_ownership to work with Pandas .apply()
+    
+    Args:
+        row_ownerships: Series containing ownership values in percentage form
+        
+    Returns:
+        float: Calculated weighted ownership value
+    """
+    # Convert Series to 2D array for vectorized function
+    ownership_array = row_ownerships.values.reshape(1, -1)
+    return calculate_weighted_ownership_vectorized(ownership_array)[0]
+
 def reassess_dupes(row: pd.Series, salary_max: int) -> float:
     return math.ceil(row['Dupes'] + ((row['salary_diff'] / 100) + ((salary_max + (salary_max - row['salary'])) / 100)) * (1 - (row['own_diff'] / 100))).clip(lower=0)
 
+def reassess_edge(row: pd.Series, Contest_Size: int) -> float:
+    row['Lineup Edge'] = row['Win%'] * ((.5 - row['Finish_percentile']) * (Contest_Size / 2.5))
+    row['Lineup Edge'] = row.apply(lambda row: row['Lineup Edge'] / (row['Dupes'] + 1) if row['Dupes'] > 0 else row['Lineup Edge'], axis=1)
+    
+    return row['Lineup Edge'] - row['Lineup Edge'].mean()
+
 def reassess_edge(refactored_frame: pd.DataFrame, original_frame: pd.DataFrame, maps_dict: dict, site_var: str, type_var: str, Contest_Size: int, strength_var: str, sport_var: str, salary_max: int) -> pd.DataFrame:
     orig_df = original_frame.copy()
     orig_df = orig_df.reset_index(drop=True)
@@ -24,12 +77,15 @@ def reassess_edge(refactored_frame: pd.DataFrame, original_frame: pd.DataFrame,
 
     change_mask = refactored_df[refactored_df['salary_diff'] != 0 | refactored_df['median_diff'] != 0 | refactored_df['own_diff'] != 0]
 
+    num_players = len([col for col in refactored_df.columns if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Win%', 'Edge', 'Weighted Own', 'Geomean', 'salary_diff', 'median_diff', 'own_diff']])
+    own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
+
     for lineups in change_mask.index:
         refactored_df.loc[lineups, 'Dupes'] = reassess_dupes(refactored_df.loc[lineups, :], salary_max)
-        refactored_df.loc[lineups, 'Finish_percentile'] = refactored_df.loc[lineups, 'Finish_percentile'] + 1
-        refactored_df.loc[lineups, 'Win%'] = refactored_df.loc[lineups, 'Win%'] + 1
-        refactored_df.loc[lineups, 'Edge'] = refactored_df.loc[lineups, 'Edge'] + 1
-        refactored_df.loc[lineups, 'Weighted Own'] = refactored_df.loc[lineups, 'Weighted Own'] + 1
-        refactored_df.loc[lineups, 'Geomean'] = refactored_df.loc[lineups, 'Geomean'] + 1
+        refactored_df.loc[lineups, 'Finish_percentile'] = refactored_df.loc[lineups, 'Finish_percentile']
+        refactored_df.loc[lineups, 'Win%'] = refactored_df.loc[lineups, 'Win%']
+        refactored_df.loc[lineups, 'Edge'] = reassess_edge(refactored_df.loc[lineups, :], Contest_Size)
+        refactored_df.loc[lineups, 'Weighted Own'] = refactored_df[own_columns].apply(calculate_weighted_ownership_wrapper, axis=1)
+        refactored_df.loc[lineups, 'Geomean'] = np.power((refactored_df.loc[lineups, own_columns] * 100).product(axis=1), 1 / len(own_columns))
 
     return refactored_df