Refactor ownership calculations in app.py to enhance accuracy for FanDuel and DraftKings. Updated dupes calculation to incorporate a scaling factor for Contest_Size, and streamlined ownership metrics by adjusting relevant columns. This improves the precision of player ownership analysis and contest lineup simulations.

app.py

@@ -551,22 +551,22 @@ with tab1:
                 Sim_Winner_Frame['GPP_Proj'] = (Sim_Winner_Frame['proj'] + Sim_Winner_Frame['Fantasy']) / 2
                 Sim_Winner_Frame['unique_id'] = Sim_Winner_Frame['proj'].astype(str) + Sim_Winner_Frame['salary'].astype(str) + Sim_Winner_Frame['Team'].astype(str) + Sim_Winner_Frame['Secondary'].astype(str)
                 # Add percent rank columns for ownership at each roster position
-                dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank']
-                own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own']
-                Sim_Winner_Frame['CPT_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,0].map(maps_dict['cpt_Own_map']).rank(pct=True)
-                Sim_Winner_Frame['FLEX1_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,1].map(maps_dict['Own_map']).rank(pct=True)
-                Sim_Winner_Frame['FLEX2_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,2].map(maps_dict['Own_map']).rank(pct=True)
-                Sim_Winner_Frame['FLEX3_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,3].map(maps_dict['Own_map']).rank(pct=True)
-                Sim_Winner_Frame['FLEX4_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,4].map(maps_dict['Own_map']).rank(pct=True)
-                Sim_Winner_Frame['FLEX5_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,5].map(maps_dict['Own_map']).rank(pct=True)
-                Sim_Winner_Frame['CPT_Own'] = Sim_Winner_Frame.iloc[:,0].map(maps_dict['cpt_Own_map']) / 100
-                Sim_Winner_Frame['FLEX1_Own'] = Sim_Winner_Frame.iloc[:,1].map(maps_dict['Own_map']) / 100
-                Sim_Winner_Frame['FLEX2_Own'] = Sim_Winner_Frame.iloc[:,2].map(maps_dict['Own_map']) / 100
-                Sim_Winner_Frame['FLEX3_Own'] = Sim_Winner_Frame.iloc[:,3].map(maps_dict['Own_map']) / 100
-                Sim_Winner_Frame['FLEX4_Own'] = Sim_Winner_Frame.iloc[:,4].map(maps_dict['Own_map']) / 100
-                Sim_Winner_Frame['FLEX5_Own'] = Sim_Winner_Frame.iloc[:,5].map(maps_dict['Own_map']) / 100
                 # Calculate Dupes column for Fanduel
                 if sim_site_var1 == 'Fanduel':
+                    dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank']
+                    own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own']
+                    calc_columns = ['own_product', 'avg_own_rank', 'dupes_calc']
+                    Sim_Winner_Frame['CPT_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,0].map(maps_dict['cpt_Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX1_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,1].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX2_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,2].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX3_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,3].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX4_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,4].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['CPT_Own'] = Sim_Winner_Frame.iloc[:,0].map(maps_dict['cpt_Own_map']) / 100
+                    Sim_Winner_Frame['FLEX1_Own'] = Sim_Winner_Frame.iloc[:,1].map(maps_dict['Own_map']) / 100
+                    Sim_Winner_Frame['FLEX2_Own'] = Sim_Winner_Frame.iloc[:,2].map(maps_dict['Own_map']) / 100
+                    Sim_Winner_Frame['FLEX3_Own'] = Sim_Winner_Frame.iloc[:,3].map(maps_dict['Own_map']) / 100
+                    Sim_Winner_Frame['FLEX4_Own'] = Sim_Winner_Frame.iloc[:,4].map(maps_dict['Own_map']) / 100
+                    
                     # Calculate ownership product and convert to probability
                     Sim_Winner_Frame['own_product'] = (Sim_Winner_Frame[own_columns].product(axis=1)) + 0.0001
                     
@@ -574,7 +574,7 @@ with tab1:
                     Sim_Winner_Frame['avg_own_rank'] = Sim_Winner_Frame[dup_count_columns].mean(axis=1)
                     
                     # Calculate dupes formula
-                    Sim_Winner_Frame['dupes_calc'] = ((Sim_Winner_Frame['own_product'] * Sim_Winner_Frame['avg_own_rank']) * Contest_Size) + ((Sim_Winner_Frame['salary'] - 59800) / 100)
+                    Sim_Winner_Frame['dupes_calc'] = ((Sim_Winner_Frame['own_product'] * Sim_Winner_Frame['avg_own_rank']) * (Contest_Size * 1.5)) + ((Sim_Winner_Frame['salary'] - 59800) / 100)
                     
                     # Round and handle negative values
                     Sim_Winner_Frame['Dupes'] = np.where(
@@ -583,6 +583,22 @@ with tab1:
                         np.round(Sim_Winner_Frame['dupes_calc'], 0) - 1
                     )
                 elif sim_site_var1 == 'Draftkings':
+                    dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank']
+                    own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own']
+                    calc_columns = ['own_product', 'avg_own_rank', 'dupes_calc']
+                    Sim_Winner_Frame['CPT_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,0].map(maps_dict['cpt_Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX1_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,1].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX2_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,2].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX3_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,3].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX4_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,4].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['FLEX5_Own_percent_rank'] = Sim_Winner_Frame.iloc[:,5].map(maps_dict['Own_map']).rank(pct=True)
+                    Sim_Winner_Frame['CPT_Own'] = Sim_Winner_Frame.iloc[:,0].map(maps_dict['cpt_Own_map']) / 100
+                    Sim_Winner_Frame['FLEX1_Own'] = Sim_Winner_Frame.iloc[:,1].map(maps_dict['Own_map']) / 100
+                    Sim_Winner_Frame['FLEX2_Own'] = Sim_Winner_Frame.iloc[:,2].map(maps_dict['Own_map']) / 100
+                    Sim_Winner_Frame['FLEX3_Own'] = Sim_Winner_Frame.iloc[:,3].map(maps_dict['Own_map']) / 100
+                    Sim_Winner_Frame['FLEX4_Own'] = Sim_Winner_Frame.iloc[:,4].map(maps_dict['Own_map']) / 100
+                    Sim_Winner_Frame['FLEX5_Own'] = Sim_Winner_Frame.iloc[:,5].map(maps_dict['Own_map']) / 100
+
                     # Calculate ownership product and convert to probability
                     Sim_Winner_Frame['own_product'] = (Sim_Winner_Frame[own_columns].product(axis=1))
                     
@@ -590,7 +606,7 @@ with tab1:
                     Sim_Winner_Frame['avg_own_rank'] = Sim_Winner_Frame[dup_count_columns].mean(axis=1)
                     
                     # Calculate dupes formula
-                    Sim_Winner_Frame['dupes_calc'] = ((Sim_Winner_Frame['own_product'] * Sim_Winner_Frame['avg_own_rank']) * Contest_Size) + ((Sim_Winner_Frame['salary'] - 49800) / 100)
+                    Sim_Winner_Frame['dupes_calc'] = ((Sim_Winner_Frame['own_product'] * Sim_Winner_Frame['avg_own_rank']) * (Contest_Size * 1.5)) + ((Sim_Winner_Frame['salary'] - 49800) / 100)
                     
                     # Round and handle negative values
                     Sim_Winner_Frame['Dupes'] = np.where(
@@ -598,12 +614,15 @@ with tab1:
                         0, 
                         np.round(Sim_Winner_Frame['dupes_calc'], 0) - 1
                     )
-                #Sim_Winner_Frame = Sim_Winner_Frame.drop(columns=dup_count_columns)
+                Sim_Winner_Frame['Dupes'] = np.round(Sim_Winner_Frame['Dupes'], 0)
+                Sim_Winner_Frame = Sim_Winner_Frame.drop(columns=dup_count_columns)
+                Sim_Winner_Frame = Sim_Winner_Frame.drop(columns=own_columns)
+                Sim_Winner_Frame = Sim_Winner_Frame.drop(columns=calc_columns)
 
                 Sim_Winner_Frame = Sim_Winner_Frame.assign(win_count=Sim_Winner_Frame['unique_id'].map(Sim_Winner_Frame['unique_id'].value_counts()))
                 
                 # Type Casting
-                type_cast_dict = {'salary': int, 'proj': np.float16, 'Fantasy': np.float16, 'GPP_Proj': np.float32, 'Own': np.float32}
+                type_cast_dict = {'salary': int, 'proj': np.float16, 'Fantasy': np.float16, 'GPP_Proj': np.float32, 'Own': np.float32, 'Dupes': int}
                 Sim_Winner_Frame = Sim_Winner_Frame.astype(type_cast_dict)
                 
                 # Sorting