Implement reassess_finish_percentile function in reassess_edge.py to recalculate finish_percentile based on ownership and contest size, enhancing accuracy in ownership adjustments. Remove debug print statements from app.py for cleaner code.

app.py

@@ -38,8 +38,6 @@ def create_position_export_dict(column_name, csv_file, site_var, type_var, sport
         # Remove any numbers from the column name to get the position
         import re
         position_filter = re.sub(r'\d+$', '', column_name)
-        
-        print(position_filter)
 
         # Filter CSV file by position
         if 'Position' in csv_file.columns:
@@ -81,12 +79,10 @@ def create_position_export_dict(column_name, csv_file, site_var, type_var, sport
         
         try:
             filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Name'])
-            print(dict(zip(filtered_df['Name'], filtered_df['Name + ID'])))
             return dict(zip(filtered_df['Name'], filtered_df['Name + ID']))
         except:
             try:
                 filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Nickname'])
-                print(dict(zip(filtered_df['Nickname'], filtered_df['Id'])))
                 return dict(zip(filtered_df['Nickname'], filtered_df['Id']))
             except:
                 # Final fallback
@@ -1097,7 +1093,6 @@ with tab2:
             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')
             
-            print(st.session_state['working_frame'].head(10))
             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()
@@ -1513,8 +1508,7 @@ with tab2:
                         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')
                         
-                        print(st.session_state['working_frame'].head(10))
-                        st.session_state['working_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'] = reassess_edge(st.session_state['working_frame'], prior_frame, st.session_state['map_dict'], Contest_Size, salary_max)
                         st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                     elif exp_submitted:
                         st.session_state['settings_base'] = False
@@ -1611,7 +1605,6 @@ with tab2:
                         st.session_state['export_base']['median'] = st.session_state['export_base']['median'].astype('float32')
                         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'], prior_frame, st.session_state['map_dict'], Contest_Size, salary_max)
                         st.session_state['export_merge'] = st.session_state['export_base'].copy()

global_func/reassess_edge.py

@@ -44,6 +44,34 @@ def calculate_weighted_ownership_single_row(row_ownerships):
     # Convert back to percentage form
     return weighted * 10000
 
+def reassess_finish_percentile(row: pd.Series, own_columns: list, Contest_Size: int) -> float:
+    """
+    Recalculate Finish_percentile for an individual row.
+    
+    Args:
+        row: pandas Series containing the row data
+        own_columns: list of ownership column names
+        
+    Returns:
+        float: new finish_percentile value
+    """
+    percentile_multiplier = 1.00
+    
+    # Step 1: Adjust Finish_percentile
+    finish_percentile = row['Finish_percentile'] + 0.005 + (0.005 * (Contest_Size / 10000))
+    
+    # Step 2: Apply multiplier and ownership adjustment
+    finish_percentile = finish_percentile * percentile_multiplier * (row['Own'] / (100 + (Contest_Size / 1000)))
+    
+    # Step 3: Count low ownership players
+    low_own_count = sum(1 for col in own_columns if row[col] < 0.10)
+    
+    # Step 4: Apply low ownership adjustment
+    if low_own_count > 0:
+        finish_percentile = finish_percentile / low_own_count
+    
+    return finish_percentile
+
 def reassess_dupes(row: pd.Series, salary_max: int) -> float:
     # Convert to signed integers to avoid uint16 wrap-around
     salary = int(row['salary'])
@@ -105,10 +133,12 @@ def reassess_edge(refactored_frame: pd.DataFrame, original_frame: pd.DataFrame,
 
     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']
+        refactored_df.loc[lineups, 'Finish_percentile'] = reassess_finish_percentile(refactored_df.loc[lineups, :], own_columns, Contest_Size)
         refactored_df.loc[lineups, 'Win%'] = refactored_df.loc[lineups, 'Win%']
         refactored_df.loc[lineups, 'Edge'] = reassess_lineup_edge(refactored_df.loc[lineups, :], Contest_Size)
         refactored_df.loc[lineups, 'Weighted Own'] = calculate_weighted_ownership_single_row(refactored_df.loc[lineups, own_columns])
         refactored_df.loc[lineups, 'Geomean'] = np.power((refactored_df.loc[lineups, own_columns] * 100).product(), 1 / len(own_columns))
+    
+    refactored_df = refactored_df.drop(columns=own_columns)
 
     return refactored_df