Add NFL support to ROO build functions and Streamlit display

app.py

@@ -20,9 +20,11 @@ from pandas import DataFrame
 from function_hold.NBA_functions import DK_NBA_ROO_Build, FD_NBA_ROO_Build
 from function_hold.MMA_functions import DK_MMA_ROO_Build, FD_MMA_ROO_Build
 from function_hold.NHL_functions import DK_NHL_ROO_Build, FD_NHL_ROO_Build
+from function_hold.NFL_functions import DK_NFL_ROO_Build, FD_NFL_ROO_Build
 
 nba_percentages_format = {'Top_finish': '{:.2%}', 'Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '4x%': '{:.2%}', '5x%': '{:.2%}', '6x%': '{:.2%}', 'GPP%': '{:.2%}'}
 nhl_percentages_format = {'Top_finish': '{:.2%}', 'Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '4x%': '{:.2%}', '5x%': '{:.2%}', '6x%': '{:.2%}', 'GPP%': '{:.2%}'}
+nfl_percentages_format = {'Top_finish': '{:.2%}', 'Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '4x%': '{:.2%}', '5x%': '{:.2%}', '6x%': '{:.2%}', 'GPP%': '{:.2%}'}
 mma_percentages_format = {'Top_finish': '{:.2%}', 'Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '100+%': '{:.2%}', '10x%': '{:.2%}', '11x%': '{:.2%}', '12x%': '{:.2%}', 'GPP%': '{:.2%}'}
 
 def load_file(upload):
@@ -53,7 +55,7 @@ with tab1:
     if sport_var == "NBA":
         st.info("upload a projections file that has Data oriented in the following format: 'Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Minutes', 'Own'")
     elif sport_var == "NFL":
-        st.info("upload a projections file that has Data oriented in the following format: 'Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Minutes', 'Own'")
+        st.info("upload a projections file that has Data oriented in the following format: 'Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Rush Yards', 'Receptions', 'Own'")
     elif sport_var == "MLB":
         st.info("upload a projections file that has Data oriented in the following format: 'Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Minutes', 'Own'")
     elif sport_var == "MMA":
@@ -68,7 +70,7 @@ with tab1:
         if sport_var == "NBA":
             template_df = pd.DataFrame(columns=['Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Minutes', 'Own'])
         elif sport_var == "NFL":
-            template_df = pd.DataFrame(columns=['Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Minutes', 'Own'])
+            template_df = pd.DataFrame(columns=['Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Rush Yards', 'Receptions', 'Own'])
         elif sport_var == "MLB":
             template_df = pd.DataFrame(columns=['Player', 'Team', 'Opp', 'Position', 'Salary', 'Median', 'Minutes', 'Own'])
         elif sport_var == "MMA":
@@ -139,6 +141,8 @@ with tab2:
                 st.dataframe(disp_file.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(nba_percentages_format, precision=2), height=1000, use_container_width = True)
             elif sport_var == "NHL":
                 st.dataframe(disp_file.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(nhl_percentages_format, precision=2), height=1000, use_container_width = True)
+            elif sport_var == "NFL":
+                st.dataframe(disp_file.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(nfl_percentages_format, precision=2), height=1000, use_container_width = True)
             elif sport_var == "MMA":
                 st.dataframe(disp_file.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(mma_percentages_format, precision=2), height=1000, use_container_width = True)
     except:

function_hold/MMA_functions.py

@@ -233,11 +233,9 @@ def DK_MMA_ROO_Build(projections_file, std_var, distribution_type):
     final_Proj['Small_Own'] = final_Proj['Player'].map(small_own_dict)
     final_Proj['Large_Own'] = final_Proj['Player'].map(large_own_dict)
     final_Proj['Cash_Own'] = final_Proj['Player'].map(cash_own_dict)
-    final_Proj['CPT_Own'] = final_Proj['Own'] / 6
-    final_Proj['LevX'] = ((final_Proj[['Top_finish', '12x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
-    final_Proj['ValX'] = ((final_Proj[['10x%', '11x%']].mean(axis=1))*100) + final_Proj['LevX']
 
-    final_Proj = final_Proj[['Player', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '100+%', '10x%', '11x%', '12x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX']]
+    final_Proj = final_Proj[['Player', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '100+%', '10x%', '11x%', '12x%', 'GPP%',
+                             'Own', 'Small_Own', 'Large_Own', 'Cash_Own']]
     final_Proj = final_Proj.sort_values(by='Median', ascending=False)
     
     return final_Proj.copy()
@@ -460,11 +458,9 @@ def FD_MMA_ROO_Build(projections_file, std_var, distribution_type):
     final_Proj['Small_Own'] = final_Proj['Player'].map(small_own_dict)
     final_Proj['Large_Own'] = final_Proj['Player'].map(large_own_dict)
     final_Proj['Cash_Own'] = final_Proj['Player'].map(cash_own_dict)
-    final_Proj['CPT_Own'] = final_Proj['Own'] / 6
-    final_Proj['LevX'] = ((final_Proj[['Top_finish', '12x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
-    final_Proj['ValX'] = ((final_Proj[['10x%', '11x%']].mean(axis=1))*100) + final_Proj['LevX']
 
-    final_Proj = final_Proj[['Player', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '100+%', '10x%', '11x%', '12x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX']]
+    final_Proj = final_Proj[['Player', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '100+%', '10x%', '11x%', '12x%', 'GPP%',
+                             'Own', 'Small_Own', 'Large_Own', 'Cash_Own']]
     final_Proj['Salary'] = final_Proj['Salary'].astype(int)
     final_Proj = final_Proj.sort_values(by='Median', ascending=False)
     

function_hold/NBA_functions.py

@@ -224,11 +224,9 @@ def DK_NBA_ROO_Build(projections_file, floor_var, ceiling_var, std_var, distribu
     final_Proj['Minutes Proj'] = final_Proj['Player'].map(min_dict)
     final_Proj['Team'] = final_Proj['name_team'].map(team_dict)
     final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
-    final_Proj['CPT_Own'] = final_Proj['Own'] / 6
-    final_Proj['LevX'] = ((final_Proj[['Top_finish', '6x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
-    final_Proj['ValX'] = ((final_Proj[['5x%', '6x%']].mean(axis=1))*100) + final_Proj['LevX']
 
-    final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX']]
+    final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%',
+                             'Own', 'Small_Own', 'Large_Own', 'Cash_Own']]
     final_Proj = final_Proj.sort_values(by='Median', ascending=False)
     
     return final_Proj.copy()
@@ -449,11 +447,9 @@ def FD_NBA_ROO_Build(projections_file, floor_var, ceiling_var, std_var, distribu
     final_Proj['Minutes Proj'] = final_Proj['Player'].map(min_dict)
     final_Proj['Team'] = final_Proj['name_team'].map(team_dict)
     final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
-    final_Proj['CPT_Own'] = final_Proj['Own'] / 6
-    final_Proj['LevX'] = ((final_Proj[['Top_finish', '6x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
-    final_Proj['ValX'] = ((final_Proj[['5x%', '6x%']].mean(axis=1))*100) + final_Proj['LevX']
 
-    final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX']]
+    final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%',
+                             'Own', 'Small_Own', 'Large_Own', 'Cash_Own']]
     final_Proj['Salary'] = final_Proj['Salary'].astype(int)
     final_Proj = final_Proj.sort_values(by='Median', ascending=False)
     

function_hold/NFL_functions.py

@@ -0,0 +1,616 @@
+from numpy import nan as np_nan
+from numpy import where as np_where
+from numpy import random as np_random
+from numpy import zeros as np_zeros
+from numpy import array as np_array
+from pandas import concat as pd_concat
+from pandas import merge as pd_merge
+from pandas import DataFrame
+
+def DK_NFL_ROO_Build(projections_file, floor_var, ceiling_var, std_var, distribution_type):
+    total_sims = 1000
+    
+    projects_raw = projections_file.copy()
+    projects_raw = projects_raw.replace("", np_nan)
+    dk_df = projects_raw.sort_values(by='Median', ascending=False)
+    
+    basic_own_df = dk_df.copy()
+    basic_own_df['name_team'] = basic_own_df['Player'] + basic_own_df['Position']
+            
+    def calculate_ownership(df, position):
+        # Filter the dataframe based on the position
+        frame = df[df['Position'].str.contains(position)]
+    
+        # Calculate Small Field Own%
+        frame['Small Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Small Field Own%'] = np_where(
+            frame['Small Field Own%'] > 75,
+            75,
+            frame['Small Field Own%']
+        )
+    
+        # Calculate Large Field Own%
+        frame['Large Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (2.5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Large Field Own%'] = np_where(
+            frame['Large Field Own%'] > 75,
+            75,
+            frame['Large Field Own%']
+        )
+    
+        # Calculate Cash Own%
+        frame['Cash Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (6 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Cash Own%'] = np_where(
+            frame['Cash Own%'] > 75,
+            75,
+            frame['Cash Own%']
+        )
+    
+        return frame
+    
+    def calculate_ownership_overall(df):
+        # Filter the dataframe based on the position
+        frame = df
+    
+        # Calculate Small Field Own%
+        frame['Small Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Small Field Own%'] = np_where(
+            frame['Small Field Own%'] > 75,
+            75,
+            frame['Small Field Own%']
+        )
+    
+        # Calculate Large Field Own%
+        frame['Large Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (2.5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Large Field Own%'] = np_where(
+            frame['Large Field Own%'] > 75,
+            75,
+            frame['Large Field Own%']
+        )
+    
+        # Calculate Cash Own%
+        frame['Cash Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (6 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Cash Own%'] = np_where(
+            frame['Cash Own%'] > 75,
+            75,
+            frame['Cash Own%']
+        )
+    
+        return frame
+    
+    # Apply the function to each dataframe
+    qb_frame = calculate_ownership(basic_own_df, 'QB')
+    rb_frame = calculate_ownership(basic_own_df, 'RB')
+    wr_frame = calculate_ownership(basic_own_df, 'WR')
+    te_frame = calculate_ownership(basic_own_df, 'TE')
+    dst_frame = calculate_ownership(basic_own_df, 'DST')
+
+    qb_reg_norm_var = 100 / qb_frame['Own'].sum()
+    qb_small_norm_var = 100 / qb_frame['Small Field Own%'].sum()
+    qb_large_norm_var = 100 / qb_frame['Large Field Own%'].sum()
+    qb_cash_norm_var = 100 / qb_frame['Cash Own%'].sum()
+    qb_frame['Own'] = qb_frame['Own'] * qb_reg_norm_var
+    qb_frame['Small Field Own%'] = qb_frame['Small Field Own%'] * qb_small_norm_var
+    qb_frame['Large Field Own%'] = qb_frame['Large Field Own%'] * qb_large_norm_var
+    qb_frame['Cash Own%'] = qb_frame['Cash Own%'] * qb_cash_norm_var
+    
+    rb_reg_norm_var = 235 / rb_frame['Own'].sum()
+    rb_small_norm_var = 235 / rb_frame['Small Field Own%'].sum()
+    rb_large_norm_var = 235 / rb_frame['Large Field Own%'].sum()
+    rb_cash_norm_var = 235 / rb_frame['Cash Own%'].sum()
+    rb_frame['Own'] = rb_frame['Own'] * rb_reg_norm_var
+    rb_frame['Small Field Own%'] = rb_frame['Small Field Own%'] * rb_small_norm_var
+    rb_frame['Large Field Own%'] = rb_frame['Large Field Own%'] * rb_large_norm_var
+    rb_frame['Cash Own%'] = rb_frame['Cash Own%'] * rb_cash_norm_var
+    
+    wr_reg_norm_var = 355 / wr_frame['Own'].sum()
+    wr_small_norm_var = 355 / wr_frame['Small Field Own%'].sum()
+    wr_large_norm_var = 355 / wr_frame['Large Field Own%'].sum()
+    wr_cash_norm_var = 355 / wr_frame['Cash Own%'].sum()
+    wr_frame['Own'] = wr_frame['Own'] * wr_reg_norm_var
+    wr_frame['Small Field Own%'] = wr_frame['Small Field Own%'] * wr_small_norm_var
+    wr_frame['Large Field Own%'] = wr_frame['Large Field Own%'] * wr_large_norm_var
+    wr_frame['Cash Own%'] = wr_frame['Cash Own%'] * wr_cash_norm_var
+    
+    te_reg_norm_var = 110 / te_frame['Own'].sum()
+    te_small_norm_var = 110 / te_frame['Small Field Own%'].sum()
+    te_large_norm_var = 110 / te_frame['Large Field Own%'].sum()
+    te_cash_norm_var = 110 / te_frame['Cash Own%'].sum()
+    te_frame['Own'] = te_frame['Own'] * te_reg_norm_var
+    te_frame['Small Field Own%'] = te_frame['Small Field Own%'] * te_small_norm_var
+    te_frame['Large Field Own%'] = te_frame['Large Field Own%'] * te_large_norm_var
+    te_frame['Cash Own%'] = te_frame['Cash Own%'] * te_cash_norm_var
+    
+    dst_reg_norm_var = 100 / dst_frame['Own'].sum()
+    dst_small_norm_var = 100 / dst_frame['Small Field Own%'].sum()
+    dst_large_norm_var = 100 / dst_frame['Large Field Own%'].sum()
+    dst_cash_norm_var = 100 / dst_frame['Cash Own%'].sum()
+    dst_frame['Own'] = dst_frame['Own'] * dst_reg_norm_var
+    dst_frame['Own'] = np_where(dst_frame['Own'] < 0, 1, dst_frame['Own'])
+    dst_frame['Small Field Own%'] = dst_frame['Small Field Own%'] * dst_small_norm_var
+    dst_frame['Small Field Own%'] = np_where(dst_frame['Small Field Own%'] < 0, 1, dst_frame['Small Field Own%'])
+    dst_frame['Large Field Own%'] = dst_frame['Large Field Own%'] * dst_large_norm_var
+    dst_frame['Large Field Own%'] = np_where(dst_frame['Large Field Own%'] < 0, 1, dst_frame['Large Field Own%'])
+    dst_frame['Cash Own%'] = dst_frame['Cash Own%'] * dst_cash_norm_var
+    dst_frame['Cash Own%'] = np_where(dst_frame['Cash Own%'] < 0, 1, dst_frame['Cash Own%'])
+    
+    basic_own_df = pd_concat([qb_frame, rb_frame, wr_frame, te_frame, dst_frame])
+    
+    basic_own_df = calculate_ownership_overall(basic_own_df)
+    
+    own_norm_var_reg = 900 / basic_own_df['Own'].sum()
+    own_norm_var_small = 900 / basic_own_df['Small Field Own%'].sum()
+    own_norm_var_large = 900 / basic_own_df['Large Field Own%'].sum()
+    own_norm_var_cash = 900 / basic_own_df['Cash Own%'].sum()
+    basic_own_df['Own'] = basic_own_df['Own'] * own_norm_var_reg
+    basic_own_df['Small_Own'] = basic_own_df['Small Field Own%'] * own_norm_var_small
+    basic_own_df['Large_Own'] = basic_own_df['Large Field Own%'] * own_norm_var_large
+    basic_own_df['Cash_Own'] = basic_own_df['Cash Own%'] * own_norm_var_cash
+    
+    basic_own_df['Own'] = np_where(basic_own_df['Own'] > 75, 75, basic_own_df['Own'])
+    
+    # Apply the function to each dataframe
+    basic_own_df = calculate_ownership_overall(basic_own_df)
+    
+    own_norm_var_reg = 900 / basic_own_df['Own'].sum()
+    own_norm_var_small = 900 / basic_own_df['Small Field Own%'].sum()
+    own_norm_var_large = 900 / basic_own_df['Large Field Own%'].sum()
+    own_norm_var_cash = 900 / basic_own_df['Cash Own%'].sum()
+    basic_own_df['Own'] = basic_own_df['Own'] * own_norm_var_reg
+    basic_own_df['Small_Own'] = basic_own_df['Small Field Own%'] * own_norm_var_small
+    basic_own_df['Large_Own'] = basic_own_df['Large Field Own%'] * own_norm_var_large
+    basic_own_df['Cash_Own'] = basic_own_df['Cash Own%'] * own_norm_var_cash
+    
+    own_dict = dict(zip(basic_own_df.Player, basic_own_df.Own))
+    small_own_dict = dict(zip(basic_own_df.Player, basic_own_df['Small Field Own%']))
+    large_own_dict = dict(zip(basic_own_df.Player, basic_own_df['Large Field Own%']))
+    cash_own_dict = dict(zip(basic_own_df.Player, basic_own_df['Cash Own%']))
+    team_dict = dict(zip(basic_own_df.Player, basic_own_df.Team))
+    opp_dict = dict(zip(basic_own_df.Player, basic_own_df.Opp))
+    
+    flex_file = projections_file[['Player', 'Position', 'Salary', 'Median', 'Rush Yards', 'Receptions']]
+    flex_file['Floor'] = np_where(flex_file['Position'] == 'QB',(flex_file['Median']*.25) + (flex_file['Rush Yards']*.01),flex_file['Median']*.25)
+    flex_file['Ceiling_raw'] = np_where(flex_file['Position'] == 'QB',(flex_file['Median'] * 1.75) + (flex_file['Rush Yards']*.01), (flex_file['Median'] * 1.75) + flex_file['Receptions'])
+    flex_file['Ceiling'] = np_where(flex_file['Position'] == 'K', (flex_file['Median'] * 1.25), flex_file['Ceiling_raw'])
+    flex_file['STD'] = (flex_file['Median']/4) + flex_file['Receptions']
+    flex_file = flex_file[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD']]
+    flex_file = flex_file.reset_index(drop=True)
+    hold_file = flex_file.copy()
+    overall_file = flex_file.copy()
+    salary_file = flex_file.copy()
+    
+    try:    
+        overall_floor_gpu = np_array(overall_file['Floor'])
+        overall_ceiling_gpu = np_array(overall_file['Ceiling'])
+        overall_median_gpu = np_array(overall_file['Median'])
+        overall_std_gpu = np_array(overall_file['STD'])
+        overall_salary_gpu = np_array(overall_file['Salary'])
+        
+        data_shape = (len(overall_file['Player']), total_sims)  # Example: 1000 rows
+        salary_array = np_zeros(data_shape)
+        sim_array = np_zeros(data_shape)
+        
+        for x in range(0, total_sims):    
+            result_gpu = overall_salary_gpu
+            salary_array[:, x] = result_gpu 
+        cupy_array = salary_array
+        
+        salary_file = salary_file.reset_index(drop=True)
+        salary_cupy = DataFrame(cupy_array, columns=list(range(0, total_sims)))
+        salary_check_file = pd_concat([salary_file, salary_cupy], axis=1)
+    except:
+        for x in range(0,total_sims):    
+            salary_file[x] = salary_file['Salary']
+        salary_check_file = salary_file.copy()
+
+    salary_file=salary_check_file.drop(['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
+
+    salary_file = salary_file.div(1000)
+    
+    try:
+        for x in range(0, total_sims):    
+            if distribution_type == 'normal':
+                # Normal distribution (existing logic)
+                result_gpu = np_random.normal(overall_median_gpu, overall_std_gpu)
+            elif distribution_type == 'poisson':
+                # Poisson distribution - using median as lambda
+                result_gpu = np_random.poisson(overall_median_gpu)
+            elif distribution_type == 'bimodal':
+                # Bimodal distribution - mixture of two normal distributions
+                # First peak centered at 80% of median, second at 120% of median
+                if np_random.random() < 0.5:
+                    result_gpu = np_random.normal(overall_floor_gpu, overall_std_gpu)
+                else:
+                    result_gpu = np_random.normal(overall_ceiling_gpu, overall_std_gpu)
+            else:
+                raise ValueError("Invalid distribution type. Must be 'normal', 'poisson', or 'bimodal'")
+                
+            sim_array[:, x] = result_gpu 
+        add_array = sim_array
+        
+        overall_file = overall_file.reset_index(drop=True)
+        df2 = DataFrame(add_array, columns=list(range(0, total_sims)))
+        check_file = pd_concat([overall_file, df2], axis=1)
+    except:
+        for x in range(0,total_sims):    
+            if distribution_type == 'normal':
+                overall_file[x] = np_random.normal(overall_file['Median'], overall_file['STD'])
+            elif distribution_type == 'poisson':
+                overall_file[x] = np_random.poisson(overall_file['Median'])
+            elif distribution_type == 'bimodal':
+                # Bimodal distribution fallback
+                if np_random.random() < 0.5:
+                    overall_file[x] = np_random.normal(overall_file['Median'] * 0.8, overall_file['STD'])
+                else:
+                    overall_file[x] = np_random.normal(overall_file['Median'] * 1.2, overall_file['STD'])
+        check_file = overall_file.copy()
+        
+    overall_file=check_file.drop(['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
+
+    players_only = hold_file[['Player']]
+    raw_lineups_file = players_only
+
+    for x in range(0,total_sims):
+        maps_dict = {'proj_map':dict(zip(hold_file.Player,overall_file[x]))}
+        raw_lineups_file[x] = sum([raw_lineups_file['Player'].map(maps_dict['proj_map'])])
+        players_only[x] = raw_lineups_file[x].rank(ascending=False)
+
+    players_only=players_only.drop(['Player'], axis=1)
+    
+    salary_2x_check = (overall_file - (salary_file*2))
+    salary_3x_check = (overall_file - (salary_file*3))
+    salary_4x_check = (overall_file - (salary_file*4))
+    
+    players_only['Average_Rank'] = players_only.mean(axis=1)
+    players_only['Top_finish'] = players_only[players_only == 1].count(axis=1)/total_sims
+    players_only['Top_5_finish'] = players_only[players_only <= 5].count(axis=1)/total_sims
+    players_only['Top_10_finish'] = players_only[players_only <= 10].count(axis=1)/total_sims
+    players_only['20+%'] = overall_file[overall_file >= 20].count(axis=1)/float(total_sims)
+    players_only['2x%'] = salary_2x_check[salary_2x_check >= 1].count(axis=1)/float(total_sims)
+    players_only['3x%'] = salary_3x_check[salary_3x_check >= 1].count(axis=1)/float(total_sims)
+    players_only['4x%'] = salary_4x_check[salary_4x_check >= 1].count(axis=1)/float(total_sims)
+    
+    players_only['Player'] = hold_file[['Player']]
+    
+    final_outcomes = players_only[['Player', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%']]
+    
+    final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
+    final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%']]
+    final_Proj['Own'] = final_Proj['Player'].map(own_dict)
+    final_Proj['Small_Field_Own'] = final_Proj['Player'].map(small_own_dict)
+    final_Proj['Large_Field_Own'] = final_Proj['Player'].map(large_own_dict)
+    final_Proj['Cash_Field_Own'] = final_Proj['Player'].map(cash_own_dict)
+    final_Proj['Team'] = final_Proj['Player'].map(team_dict)
+    final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
+    final_Proj = final_Proj[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%',
+                                'Own', 'Small_Field_Own', 'Large_Field_Own', 'Cash_Field_Own']]
+    final_Proj = final_Proj.sort_values(by='Median', ascending=False)
+    
+    return final_Proj.copy()
+
+def FD_NFL_ROO_Build(projections_file, floor_var, ceiling_var, std_var, distribution_type):
+    total_sims = 1000
+        
+    projects_raw = projections_file.copy()
+    fd_df = projects_raw.sort_values(by='Median', ascending=False)
+    
+    basic_own_df = fd_df.copy()
+    basic_own_df['name_team'] = basic_own_df['Player'] + basic_own_df['Position']
+            
+    def calculate_ownership(df, position):
+        # Filter the dataframe based on the position
+        frame = df[df['Position'].str.contains(position)]
+    
+        # Calculate Small Field Own%
+        frame['Small Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Small Field Own%'] = np_where(
+            frame['Small Field Own%'] > 75,
+            75,
+            frame['Small Field Own%']
+        )
+    
+        # Calculate Large Field Own%
+        frame['Large Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (2.5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Large Field Own%'] = np_where(
+            frame['Large Field Own%'] > 75,
+            75,
+            frame['Large Field Own%']
+        )
+    
+        # Calculate Cash Own%
+        frame['Cash Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (6 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Cash Own%'] = np_where(
+            frame['Cash Own%'] > 75,
+            75,
+            frame['Cash Own%']
+        )
+    
+        return frame
+    
+    def calculate_ownership_overall(df):
+        # Filter the dataframe based on the position
+        frame = df
+    
+        # Calculate Small Field Own%
+        frame['Small Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Small Field Own%'] = np_where(
+            frame['Small Field Own%'] > 75,
+            75,
+            frame['Small Field Own%']
+        )
+    
+        # Calculate Large Field Own%
+        frame['Large Field Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (2.5 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Large Field Own%'] = np_where(
+            frame['Large Field Own%'] > 75,
+            75,
+            frame['Large Field Own%']
+        )
+    
+        # Calculate Cash Own%
+        frame['Cash Own%'] = np_where(
+            (frame['Own'] - frame['Own'].mean() >= 0),
+            frame['Own'] * (6 * (frame['Own'] - frame['Own'].mean()) / 100) + frame['Own'].mean(),
+            frame['Own']
+        )
+        frame['Cash Own%'] = np_where(
+            frame['Cash Own%'] > 75,
+            75,
+            frame['Cash Own%']
+        )
+    
+        return frame
+    
+    # Apply the function to each dataframe
+    qb_frame = calculate_ownership(basic_own_df, 'QB')
+    rb_frame = calculate_ownership(basic_own_df, 'RB')
+    wr_frame = calculate_ownership(basic_own_df, 'WR')
+    te_frame = calculate_ownership(basic_own_df, 'TE')
+    dst_frame = calculate_ownership(basic_own_df, 'D')
+    
+    qb_reg_norm_var = 100 / qb_frame['Own'].sum()
+    qb_small_norm_var = 100 / qb_frame['Small Field Own%'].sum()
+    qb_large_norm_var = 100 / qb_frame['Large Field Own%'].sum()
+    qb_cash_norm_var = 100 / qb_frame['Cash Own%'].sum()
+    qb_frame['Own'] = qb_frame['Own'] * qb_reg_norm_var
+    qb_frame['Small Field Own%'] = qb_frame['Small Field Own%'] * qb_small_norm_var
+    qb_frame['Large Field Own%'] = qb_frame['Large Field Own%'] * qb_large_norm_var
+    qb_frame['Cash Own%'] = qb_frame['Cash Own%'] * qb_cash_norm_var
+    
+    rb_reg_norm_var = 235 / rb_frame['Own'].sum()
+    rb_small_norm_var = 235 / rb_frame['Small Field Own%'].sum()
+    rb_large_norm_var = 235 / rb_frame['Large Field Own%'].sum()
+    rb_cash_norm_var = 235 / rb_frame['Cash Own%'].sum()
+    rb_frame['Own'] = rb_frame['Own'] * rb_reg_norm_var
+    rb_frame['Small Field Own%'] = rb_frame['Small Field Own%'] * rb_small_norm_var
+    rb_frame['Large Field Own%'] = rb_frame['Large Field Own%'] * rb_large_norm_var
+    rb_frame['Cash Own%'] = rb_frame['Cash Own%'] * rb_cash_norm_var
+    
+    wr_reg_norm_var = 355 / wr_frame['Own'].sum()
+    wr_small_norm_var = 355 / wr_frame['Small Field Own%'].sum()
+    wr_large_norm_var = 355 / wr_frame['Large Field Own%'].sum()
+    wr_cash_norm_var = 355 / wr_frame['Cash Own%'].sum()
+    wr_frame['Own'] = wr_frame['Own'] * wr_reg_norm_var
+    wr_frame['Small Field Own%'] = wr_frame['Small Field Own%'] * wr_small_norm_var
+    wr_frame['Large Field Own%'] = wr_frame['Large Field Own%'] * wr_large_norm_var
+    wr_frame['Cash Own%'] = wr_frame['Cash Own%'] * wr_cash_norm_var
+    
+    te_reg_norm_var = 110 / te_frame['Own'].sum()
+    te_small_norm_var = 110 / te_frame['Small Field Own%'].sum()
+    te_large_norm_var = 110 / te_frame['Large Field Own%'].sum()
+    te_cash_norm_var = 110 / te_frame['Cash Own%'].sum()
+    te_frame['Own'] = te_frame['Own'] * te_reg_norm_var
+    te_frame['Small Field Own%'] = te_frame['Small Field Own%'] * te_small_norm_var
+    te_frame['Large Field Own%'] = te_frame['Large Field Own%'] * te_large_norm_var
+    te_frame['Cash Own%'] = te_frame['Cash Own%'] * te_cash_norm_var
+    
+    dst_reg_norm_var = 100 / dst_frame['Own'].sum()
+    dst_small_norm_var = 100 / dst_frame['Small Field Own%'].sum()
+    dst_large_norm_var = 100 / dst_frame['Large Field Own%'].sum()
+    dst_cash_norm_var = 100 / dst_frame['Cash Own%'].sum()
+    dst_frame['Own'] = dst_frame['Own'] * dst_reg_norm_var
+    dst_frame['Own'] = np_where(dst_frame['Own'] < 0, 1, dst_frame['Own'])
+    dst_frame['Small Field Own%'] = dst_frame['Small Field Own%'] * dst_small_norm_var
+    dst_frame['Small Field Own%'] = np_where(dst_frame['Small Field Own%'] < 0, 1, dst_frame['Small Field Own%'])
+    dst_frame['Large Field Own%'] = dst_frame['Large Field Own%'] * dst_large_norm_var
+    dst_frame['Large Field Own%'] = np_where(dst_frame['Large Field Own%'] < 0, 1, dst_frame['Large Field Own%'])
+    dst_frame['Cash Own%'] = dst_frame['Cash Own%'] * dst_cash_norm_var
+    dst_frame['Cash Own%'] = np_where(dst_frame['Cash Own%'] < 0, 1, dst_frame['Cash Own%'])
+    
+    basic_own_df = pd_concat([qb_frame, rb_frame, wr_frame, te_frame, dst_frame])
+    
+    basic_own_df = calculate_ownership_overall(basic_own_df)
+    
+    own_norm_var_reg = 900 / basic_own_df['Own'].sum()
+    own_norm_var_small = 900 / basic_own_df['Small Field Own%'].sum()
+    own_norm_var_large = 900 / basic_own_df['Large Field Own%'].sum()
+    own_norm_var_cash = 900 / basic_own_df['Cash Own%'].sum()
+    basic_own_df['Own'] = basic_own_df['Own'] * own_norm_var_reg
+    basic_own_df['Small_Own'] = basic_own_df['Small Field Own%'] * own_norm_var_small
+    basic_own_df['Large_Own'] = basic_own_df['Large Field Own%'] * own_norm_var_large
+    basic_own_df['Cash_Own'] = basic_own_df['Cash Own%'] * own_norm_var_cash
+    
+    basic_own_df['Own'] = np_where(basic_own_df['Own'] > 75, 75, basic_own_df['Own'])
+    
+    # Apply the function to each dataframe
+    basic_own_df = calculate_ownership_overall(basic_own_df)
+    
+    own_norm_var_reg = 900 / basic_own_df['Own'].sum()
+    own_norm_var_small = 900 / basic_own_df['Small Field Own%'].sum()
+    own_norm_var_large = 900 / basic_own_df['Large Field Own%'].sum()
+    own_norm_var_cash = 900 / basic_own_df['Cash Own%'].sum()
+    basic_own_df['Own'] = basic_own_df['Own'] * own_norm_var_reg
+    basic_own_df['Small_Own'] = basic_own_df['Small Field Own%'] * own_norm_var_small
+    basic_own_df['Large_Own'] = basic_own_df['Large Field Own%'] * own_norm_var_large
+    basic_own_df['Cash_Own'] = basic_own_df['Cash Own%'] * own_norm_var_cash
+    
+    own_dict = dict(zip(basic_own_df.Player, basic_own_df.Own))
+    small_own_dict = dict(zip(basic_own_df.Player, basic_own_df['Small Field Own%']))
+    large_own_dict = dict(zip(basic_own_df.Player, basic_own_df['Large Field Own%']))
+    cash_own_dict = dict(zip(basic_own_df.Player, basic_own_df['Cash Own%']))
+    team_dict = dict(zip(basic_own_df.Player, basic_own_df.Team))
+    opp_dict = dict(zip(basic_own_df.Player, basic_own_df.Opp))
+    
+    flex_file = projections_file[['Player', 'Position', 'Salary', 'Median', 'Rush Yards', 'Receptions']]
+    flex_file['Floor'] = np_where(flex_file['Position'] == 'QB',(flex_file['Median']*.25) + (flex_file['Rush Yards']*.01),flex_file['Median']*.25)
+    flex_file['Ceiling_raw'] = np_where(flex_file['Position'] == 'QB',(flex_file['Median'] * 1.75) + (flex_file['Rush Yards']*.01), (flex_file['Median'] * 1.75) + flex_file['Receptions'])
+    flex_file['Ceiling'] = np_where(flex_file['Position'] == 'K', (flex_file['Median'] * 1.25), flex_file['Ceiling_raw'])
+    flex_file['STD'] = (flex_file['Median']/4) + flex_file['Receptions']
+    flex_file = flex_file[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD']]
+    flex_file = flex_file.reset_index(drop=True)
+    hold_file = flex_file.copy()
+    overall_file = flex_file.copy()
+    salary_file = flex_file.copy()
+    
+    try:    
+        overall_floor_gpu = np_array(overall_file['Floor'])
+        overall_ceiling_gpu = np_array(overall_file['Ceiling'])
+        overall_median_gpu = np_array(overall_file['Median'])
+        overall_std_gpu = np_array(overall_file['STD'])
+        overall_salary_gpu = np_array(overall_file['Salary'])
+        
+        data_shape = (len(overall_file['Player']), total_sims)  # Example: 1000 rows
+        salary_array = np_zeros(data_shape)
+        sim_array = np_zeros(data_shape)
+        
+        for x in range(0, total_sims):    
+            result_gpu = overall_salary_gpu
+            salary_array[:, x] = result_gpu 
+        cupy_array = salary_array
+        
+        salary_file = salary_file.reset_index(drop=True)
+        salary_cupy = DataFrame(cupy_array, columns=list(range(0, total_sims)))
+        salary_check_file = pd_concat([salary_file, salary_cupy], axis=1)
+    except:
+        for x in range(0,total_sims):    
+            salary_file[x] = salary_file['Salary']
+        salary_check_file = salary_file.copy()
+
+    salary_file=salary_check_file.drop(['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
+
+    salary_file = salary_file.div(1000)
+    
+    try:
+        for x in range(0, total_sims):    
+            if distribution_type == 'normal':
+                # Normal distribution (existing logic)
+                result_gpu = np_random.normal(overall_median_gpu, overall_std_gpu)
+            elif distribution_type == 'poisson':
+                # Poisson distribution - using median as lambda
+                result_gpu = np_random.poisson(overall_median_gpu)
+            elif distribution_type == 'bimodal':
+                # Bimodal distribution - mixture of two normal distributions
+                # First peak centered at 80% of median, second at 120% of median
+                if np_random.random() < 0.5:
+                    result_gpu = np_random.normal(overall_floor_gpu, overall_std_gpu)
+                else:
+                    result_gpu = np_random.normal(overall_ceiling_gpu, overall_std_gpu)
+            else:
+                raise ValueError("Invalid distribution type. Must be 'normal', 'poisson', or 'bimodal'")
+                
+            sim_array[:, x] = result_gpu 
+        add_array = sim_array
+        
+        overall_file = overall_file.reset_index(drop=True)
+        df2 = DataFrame(add_array, columns=list(range(0, total_sims)))
+        check_file = pd_concat([overall_file, df2], axis=1)
+    except:
+        for x in range(0,total_sims):    
+            if distribution_type == 'normal':
+                overall_file[x] = np_random.normal(overall_file['Median'], overall_file['STD'])
+            elif distribution_type == 'poisson':
+                overall_file[x] = np_random.poisson(overall_file['Median'])
+            elif distribution_type == 'bimodal':
+                # Bimodal distribution fallback
+                if np_random.random() < 0.5:
+                    overall_file[x] = np_random.normal(overall_file['Median'] * 0.8, overall_file['STD'])
+                else:
+                    overall_file[x] = np_random.normal(overall_file['Median'] * 1.2, overall_file['STD'])
+        check_file = overall_file.copy()
+        
+    overall_file=check_file.drop(['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
+
+    players_only = hold_file[['Player']]
+    raw_lineups_file = players_only
+
+    for x in range(0,total_sims):
+        maps_dict = {'proj_map':dict(zip(hold_file.Player,overall_file[x]))}
+        raw_lineups_file[x] = sum([raw_lineups_file['Player'].map(maps_dict['proj_map'])])
+        players_only[x] = raw_lineups_file[x].rank(ascending=False)
+
+    players_only=players_only.drop(['Player'], axis=1)
+        
+    salary_2x_check = (overall_file - (salary_file*2))
+    salary_3x_check = (overall_file - (salary_file*3))
+    salary_4x_check = (overall_file - (salary_file*4))
+    
+    players_only['Average_Rank'] = players_only.mean(axis=1)
+    players_only['Top_finish'] = players_only[players_only == 1].count(axis=1)/total_sims
+    players_only['Top_5_finish'] = players_only[players_only <= 5].count(axis=1)/total_sims
+    players_only['Top_10_finish'] = players_only[players_only <= 10].count(axis=1)/total_sims
+    players_only['20+%'] = overall_file[overall_file >= 20].count(axis=1)/float(total_sims)
+    players_only['2x%'] = salary_2x_check[salary_2x_check >= 1].count(axis=1)/float(total_sims)
+    players_only['3x%'] = salary_3x_check[salary_3x_check >= 1].count(axis=1)/float(total_sims)
+    players_only['4x%'] = salary_4x_check[salary_4x_check >= 1].count(axis=1)/float(total_sims)
+    
+    players_only['Player'] = hold_file[['Player']]
+    
+    final_outcomes = players_only[['Player', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%']]
+    
+    final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
+    final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%']]
+    final_Proj['Own'] = final_Proj['Player'].map(own_dict)
+    final_Proj['Small_Field_Own'] = final_Proj['Player'].map(small_own_dict)
+    final_Proj['Large_Field_Own'] = final_Proj['Player'].map(large_own_dict)
+    final_Proj['Cash_Field_Own'] = final_Proj['Player'].map(cash_own_dict)
+    final_Proj['Team'] = final_Proj['Player'].map(team_dict)
+    final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
+    final_Proj = final_Proj[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%',
+                                'Own', 'Small_Field_Own', 'Large_Field_Own', 'Cash_Field_Own']]
+    final_Proj['Salary'] = final_Proj['Salary'].astype(int)
+    final_Proj = final_Proj.sort_values(by='Median', ascending=False)
+    
+    return final_Proj.copy()

function_hold/NHL_functions.py

@@ -240,7 +240,8 @@ def DK_NHL_ROO_Build(projections_file, floor_var, ceiling_var, std_var, distribu
     final_Proj['name_team'] = final_Proj['Player'] + final_Proj['Position']
     final_Proj['Team'] = final_Proj['name_team'].map(basic_team_dict)
     final_Proj['Opp'] = final_Proj['Player'].map(basic_opp_dict)
-    final_Proj = final_Proj[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', 'Own', 'Small Field Own%', 'Large Field Own%', 'Cash Own%']]
+    final_Proj = final_Proj[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', 'Own',
+                             'Small Field Own%', 'Large Field Own%', 'Cash Own%']]
     final_Proj = final_Proj.sort_values(by='Median', ascending=False)
     
     return final_Proj.copy()
@@ -467,7 +468,7 @@ def FD_NHL_ROO_Build(projections_file, floor_var, ceiling_var, std_var, distribu
 
     final_outcomes = players_only[['Player', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%']]
 
-    final_Proj = merge(hold_file, final_outcomes, on="Player")
+    final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
     final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%']]
     final_Proj['Own'] = final_Proj['Player'].map(basic_own_dict).astype(float)
     final_Proj['Small Field Own%'] = final_Proj['Player'].map(small_own_dict).astype(float)
@@ -476,7 +477,8 @@ def FD_NHL_ROO_Build(projections_file, floor_var, ceiling_var, std_var, distribu
     final_Proj['name_team'] = final_Proj['Player'] + final_Proj['Position']
     final_Proj['Team'] = final_Proj['name_team'].map(basic_team_dict)
     final_Proj['Opp'] = final_Proj['Player'].map(basic_opp_dict)
-    final_Proj = final_Proj[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', 'Own', 'Small Field Own%', 'Large Field Own%', 'Cash Own%']]
+    final_Proj = final_Proj[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', 'Own',
+                             'Small Field Own%', 'Large Field Own%', 'Cash Own%']]
     final_Proj['Salary'] = final_Proj['Salary'].astype(int)
     final_Proj = final_Proj.sort_values(by='Median', ascending=False)