Refactor predict_dupes function to enhance League of Legends (LOL) support, adding specific calculations for ownership percentages and ranks, while maintaining existing logic for CS2. This improves accuracy in player predictions and ensures consistent handling of duplicate calculations across both sports.

global_func/predict_dupes.py

@@ -435,7 +435,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 np.round(portfolio['dupes_calc'], 0) - 1
             )
         elif type_var == 'Classic':
-            if sport_var == 'CS2' or sport_var == 'LOL':
+            if sport_var == 'CS2':
                 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', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
@@ -475,6 +475,55 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((50000 - portfolio['salary']) / 100)
                 portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier
 
+                # Round and handle negative values
+                portfolio['Dupes'] = np.where(
+                    np.round(portfolio['dupes_calc'], 0) <= 0,
+                    0, 
+                    np.round(portfolio['dupes_calc'], 0) - 1
+                )
+            if sport_var == 'LOL':
+                dup_count_columns = ['CPT_Own_percent_rank', 'TOP_Own_percent_rank', 'JNG_Own_percent_rank', 'MID_Own_percent_rank', 'ADC_Own_percent_rank', 'SUP_Own_percent_rank', 'Team_Own_percent_rank']
+                own_columns = ['CPT_Own', 'TOP_Own', 'JNG_Own', 'MID_Own', 'ADC_Own', 'SUP_Own', 'Team_Own']
+                calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+                # Get the original player columns (first 6 columns excluding salary, median, Own)
+                player_columns = [col for col in portfolio.columns[:6] if col not in ['salary', 'median', 'Own']]
+                
+                flex_ownerships = pd.concat([
+                    portfolio.iloc[:,1].map(maps_dict['own_map']),
+                    portfolio.iloc[:,2].map(maps_dict['own_map']),
+                    portfolio.iloc[:,3].map(maps_dict['own_map']),
+                    portfolio.iloc[:,4].map(maps_dict['own_map']),
+                    portfolio.iloc[:,5].map(maps_dict['own_map']),
+                    portfolio.iloc[:,6].map(maps_dict['own_map'])
+                ])
+                flex_rank = flex_ownerships.rank(pct=True)
+                
+                # Assign ranks back to individual columns using the same rank scale
+                portfolio['CPT_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).rank(pct=True)
+                portfolio['TOP_Own_percent_rank'] = portfolio.iloc[:,1].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['JNG_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['MID_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['ADC_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['SUP_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['Team_Own_percent_rank'] = portfolio.iloc[:,6].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+
+                portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
+                portfolio['TOP_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['JNG_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['MID_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['ADC_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['SUP_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['Team_Own'] = portfolio.iloc[:,6].map(maps_dict['own_map']).astype('float32') / 100
+
+                portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+                portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
+                portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
+                portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
+                
+                # Calculate dupes formula
+                portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((50000 - portfolio['salary']) / 100)
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier
+
                 # Round and handle negative values
                 portfolio['Dupes'] = np.where(
                     np.round(portfolio['dupes_calc'], 0) <= 0,