removing Fanduel specific logic from Predict Dupes

app.py

@@ -1290,19 +1290,17 @@ if selected_tab == 'Manage Portfolio':
             with st.expander('Micro Filter Options'):
                 with st.form(key='micro_filter_form'):
                     player_names = set()
-                    print(st.session_state['working_frame'].columns)
                     for col in st.session_state['working_frame'].columns:
                         if col not in excluded_cols:
                             player_names.update(st.session_state['working_frame'][col].unique())
                     if type_var == 'Showdown':
                         cpt_flex_focus = st.selectbox("Focus on Overall, CPT, or FLEX?", options=['Overall', 'CPT', 'FLEX'], index=0)
-                    # Will sort these again after checking
-                    player_lock = st.multiselect("Lock players?", options=list(player_names), default=[])
-                    player_remove = st.multiselect("Remove players?", options=list(player_names), default=[])
-                    team_include = st.multiselect("Include teams?", options=list(set(st.session_state['projections_df']['team'].unique())), default=[])
-                    team_remove = st.multiselect("Remove teams?", options=list(set(st.session_state['projections_df']['team'].unique())), default=[])
+                    player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[])
+                    player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[])
+                    team_include = st.multiselect("Include teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
+                    team_remove = st.multiselect("Remove teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
                     if sport_var in stacking_sports:
-                        size_include = st.multiselect("Include sizes?", options=list(set(st.session_state['working_frame']['Size'].unique())), default=[])
+                        size_include = st.multiselect("Include sizes?", options=sorted(list(set(st.session_state['working_frame']['Size'].unique()))), default=[])
                     else:
                         size_include = []
                     

global_func/predict_dupes.py

@@ -118,16 +118,45 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
         percentile_multiplier = 1.10
     max_ownership = max(maps_dict['own_map'].values()) / 100
     average_ownership = np.mean(list(maps_dict['own_map'].values())) / 100
-    if site_var == 'Fanduel':
-        if type_var == 'Showdown':
-            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', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
-            # Get the original player columns (first 5 columns excluding salary, median, Own)
-            player_columns = [col for col in portfolio.columns[:5] if col not in ['salary', 'median', 'Own']]
 
-            n_rows = len(portfolio)
+    if type_var == 'Showdown':
+        if sport_var == 'GOLF':
+            dup_count_columns = ['FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank', 'FLEX6_Own_percent_rank']
+            own_columns = ['FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own', 'FLEX6_Own']
+        else:
+            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']
+        # 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']]
+        n_rows = len(portfolio)
+        
+        # Assign ranks back to individual columns using the same rank scale
+        if sport_var == 'GOLF':
+            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)
+
+            portfolio['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
+            portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
+            portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+            portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+            portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
+            portfolio['FLEX6_Own_percent_rank'] = flex_rank.iloc[5*n_rows:6*n_rows].values
 
+            portfolio['FLEX1_Own'] = portfolio.iloc[:,0].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX2_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX3_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX4_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX5_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX6_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
+        else:
             flex_ownerships = pd.concat([
                 portfolio.iloc[:,1].map(maps_dict['own_map']),
                 portfolio.iloc[:,2].map(maps_dict['own_map']),
@@ -137,6 +166,59 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             ])
             flex_rank = flex_ownerships.rank(pct=True)
             
+            portfolio['CPT_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).rank(pct=True)
+            portfolio['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
+            portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
+            portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+            portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+            portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
+
+            portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
+            portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX5_Own'] = portfolio.iloc[:,5].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'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
+        portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (120 + (Contest_Size / 1000)))
+
+        # Round and handle negative values
+        portfolio['Dupes'] = np.where(
+            portfolio['salary'] == max_salary,
+            portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+            portfolio['dupes_calc']
+        )
+        portfolio['Dupes'] = np.where(
+            np.round(portfolio['Dupes'], 0) <= 0,
+            0, 
+            np.round(portfolio['Dupes'], 0) - 1
+        )
+    elif type_var == 'Classic':
+        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']
+            # 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']]
+
+            n_rows = len(portfolio)
+
+            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'])
+            ])
+            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['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
@@ -151,16 +233,72 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
             portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
             portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
-            
+
             portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 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']) * (portfolio['Own'] / 100) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = ((portfolio['own_product'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 50) - ((max_salary - portfolio['salary']) / 50)
             portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
+
+            # Round and handle negative values
+            portfolio['Dupes'] = np.where(
+                portfolio['salary'] == max_salary,
+                portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                portfolio['dupes_calc']
+            )
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['Dupes'], 0) <= 0,
+                0, 
+                np.round(portfolio['Dupes'], 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[:7] if col not in ['salary', 'median', 'Own']]
+            
+            n_rows = len(portfolio)
+
+            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'] = flex_rank.iloc[0:n_rows].values
+            portfolio['JNG_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values
+            portfolio['MID_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+            portfolio['ADC_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+            portfolio['SUP_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
+            portfolio['Team_Own_percent_rank'] = flex_rank.iloc[5*n_rows:6*n_rows].values
+
+            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)) * max(Contest_Size / 10000, 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'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 50) - ((max_salary - portfolio['salary']) / 50)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
+
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
                 portfolio['salary'] == max_salary,
@@ -172,11 +310,11 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 0, 
                 np.round(portfolio['Dupes'], 0) - 1
             )
-        elif type_var == 'Classic':
+        elif sport_var == 'GOLF':
             num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
             dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
             own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
-            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            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 num_players columns excluding salary, median, Own)
             player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
             
@@ -202,78 +340,25 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 0, 
                 np.round(portfolio['Dupes'], 0) - 1
             )
-
-    elif site_var == 'Draftkings':
-        if type_var == 'Showdown':
-            if sport_var == 'GOLF':
-                dup_count_columns = ['FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank', 'FLEX6_Own_percent_rank']
-                own_columns = ['FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own', 'FLEX6_Own']
-            else:
-                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']
+        else:
+            num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
+            dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
+            own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
             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']]
-            n_rows = len(portfolio)
+            # Get the original player columns (first num_players columns excluding salary, median, Own)
+            player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
+            
+            for i in range(1, num_players + 1):
+                portfolio[f'player_{i}_percent_rank'] = portfolio.iloc[:,i-1].map(maps_dict['own_percent_rank'])
+                portfolio[f'player_{i}_own'] = portfolio.iloc[:,i-1].map(maps_dict['own_map']).astype('float32') / 100
             
-            # Assign ranks back to individual columns using the same rank scale
-            if sport_var == 'GOLF':
-                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)
-
-                portfolio['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
-                portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
-                portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
-                portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
-                portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
-                portfolio['FLEX6_Own_percent_rank'] = flex_rank.iloc[5*n_rows:6*n_rows].values
-
-                portfolio['FLEX1_Own'] = portfolio.iloc[:,0].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX2_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX3_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX4_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX5_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX6_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
-            else:
-                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'])
-                ])
-                flex_rank = flex_ownerships.rank(pct=True)
-                
-                portfolio['CPT_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).rank(pct=True)
-                portfolio['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
-                portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
-                portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
-                portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
-                portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
-
-                portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
-                portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX5_Own'] = portfolio.iloc[:,5].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'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
-            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (120 + (Contest_Size / 1000)))
-
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
                 portfolio['salary'] == max_salary,
@@ -285,176 +370,6 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 0, 
                 np.round(portfolio['Dupes'], 0) - 1
             )
-        elif type_var == 'Classic':
-            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']
-                # 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']]
-
-                n_rows = len(portfolio)
-
-                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'])
-                ])
-                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['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
-                portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
-                portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
-                portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
-                portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
-
-                portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
-                portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
-                portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
-
-                portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 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'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 50) - ((max_salary - portfolio['salary']) / 50)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
-
-                # Round and handle negative values
-                portfolio['Dupes'] = np.where(
-                    portfolio['salary'] == max_salary,
-                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
-                    portfolio['dupes_calc']
-                )
-                portfolio['Dupes'] = np.where(
-                    np.round(portfolio['Dupes'], 0) <= 0,
-                    0, 
-                    np.round(portfolio['Dupes'], 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[:7] if col not in ['salary', 'median', 'Own']]
-                
-                n_rows = len(portfolio)
-
-                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'] = flex_rank.iloc[0:n_rows].values
-                portfolio['JNG_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values
-                portfolio['MID_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
-                portfolio['ADC_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
-                portfolio['SUP_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
-                portfolio['Team_Own_percent_rank'] = flex_rank.iloc[5*n_rows:6*n_rows].values
-
-                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)) * max(Contest_Size / 10000, 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'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 50) - ((max_salary - portfolio['salary']) / 50)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
-
-                # Round and handle negative values
-                portfolio['Dupes'] = np.where(
-                    portfolio['salary'] == max_salary,
-                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
-                    portfolio['dupes_calc']
-                )
-                portfolio['Dupes'] = np.where(
-                    np.round(portfolio['Dupes'], 0) <= 0,
-                    0, 
-                    np.round(portfolio['Dupes'], 0) - 1
-                )
-            elif sport_var == 'GOLF':
-                num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
-                dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
-                own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
-                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 num_players columns excluding salary, median, Own)
-                player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
-                
-                for i in range(1, num_players + 1):
-                    portfolio[f'player_{i}_percent_rank'] = portfolio.iloc[:,i-1].map(maps_dict['own_percent_rank'])
-                    portfolio[f'player_{i}_own'] = portfolio.iloc[:,i-1].map(maps_dict['own_map']).astype('float32') / 100
-                
-                portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 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)
-                
-                portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
-                # Round and handle negative values
-                portfolio['Dupes'] = np.where(
-                    portfolio['salary'] == max_salary,
-                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
-                    portfolio['dupes_calc']
-                )
-                portfolio['Dupes'] = np.where(
-                    np.round(portfolio['Dupes'], 0) <= 0,
-                    0, 
-                    np.round(portfolio['Dupes'], 0) - 1
-                )
-            else:
-                num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
-                dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
-                own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
-                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 num_players columns excluding salary, median, Own)
-                player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
-                
-                for i in range(1, num_players + 1):
-                    portfolio[f'player_{i}_percent_rank'] = portfolio.iloc[:,i-1].map(maps_dict['own_percent_rank'])
-                    portfolio[f'player_{i}_own'] = portfolio.iloc[:,i-1].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)
-                
-                portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
-                # Round and handle negative values
-                portfolio['Dupes'] = np.where(
-                    portfolio['salary'] == max_salary,
-                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
-                    portfolio['dupes_calc']
-                )
-                portfolio['Dupes'] = np.where(
-                    np.round(portfolio['Dupes'], 0) <= 0,
-                    0, 
-                    np.round(portfolio['Dupes'], 0) - 1
-                )
                 
 
     portfolio['Dupes'] = np.round(portfolio['Dupes'], 0)