Update app.py

app.py

@@ -8,7 +8,6 @@ for name in dir():
 import pulp
 import numpy as np
 import pandas as pd
-import polars as pl
 import streamlit as st
 import gspread
 import time
@@ -67,18 +66,10 @@ def player_stat_table():
 def load_dk_player_projections():
     sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
     worksheet = sh.worksheet('DK_ROO')
-    
-    # Get all records from the Google Sheet
-    records = worksheet.get_all_records()
-    
-    # Convert to Polars DataFrame
-    load_display = pl.DataFrame(records)
-    
-    # Replace empty strings with np.nan
-    load_display = load_display.apply(lambda df: df.replace("", np.nan))
-    
-    # Drop rows where 'Median' is NaN
-    raw_display = load_display.filter(pl.col("Median").is_not_null())
+    load_display = pd.DataFrame(worksheet.get_all_records())
+    load_display.replace('', np.nan, inplace=True)
+    raw_display = load_display.dropna(subset=['Median'])
+    del load_display
 
     return raw_display
 
@@ -86,39 +77,30 @@ def load_dk_player_projections():
 def load_fd_player_projections():
     sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
     worksheet = sh.worksheet('FD_ROO')
-    
-    # Get all records from the Google Sheet
-    records = worksheet.get_all_records()
-    
-    # Convert to Polars DataFrame
-    load_display = pl.DataFrame(records)
-    
-    # Replace empty strings with np.nan
-    load_display = load_display.apply(lambda df: df.replace("", np.nan))
-    
-    # Drop rows where 'Median' is NaN
-    raw_display = load_display.filter(pl.col("Median").is_not_null())
+    load_display = pd.DataFrame(worksheet.get_all_records())
+    load_display.replace('', np.nan, inplace=True)
+    raw_display = load_display.dropna(subset=['Median'])
+    del load_display
 
     return raw_display
 
 @st.cache_resource(ttl = 60)
 def set_export_ids():
     sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    # Fetch DK_ROO worksheet and prepare Polars DataFrame
-    worksheet_dk = sh.worksheet('DK_ROO')
-    records_dk = worksheet_dk.get_all_records()
-    load_display_dk = pl.DataFrame(records_dk)
-    load_display_dk = load_display_dk.apply(lambda df: df.replace("", np.nan))
-    raw_display_dk = load_display_dk.filter(pl.col("Median").is_not_null())
-    dk_ids = dict(zip(raw_display_dk["Player"].to_list(), raw_display_dk["player_id"].to_list()))
+    worksheet = sh.worksheet('DK_ROO')
+    load_display = pd.DataFrame(worksheet.get_all_records())
+    load_display.replace('', np.nan, inplace=True)
+    raw_display = load_display.dropna(subset=['Median'])
+    dk_ids = dict(zip(raw_display['Player'], raw_display['player_id']))
     
-    # Fetch FD_ROO worksheet and prepare Polars DataFrame
-    worksheet_fd = sh.worksheet('FD_ROO')
-    records_fd = worksheet_fd.get_all_records()
-    load_display_fd = pl.DataFrame(records_fd)
-    load_display_fd = load_display_fd.apply(lambda df: df.replace("", np.nan))
-    raw_display_fd = load_display_fd.filter(pl.col("Median").is_not_null())
-    fd_ids = dict(zip(raw_display_fd["Player"].to_list(), raw_display_fd["player_id"].to_list()))
+    worksheet = sh.worksheet('FD_ROO')
+    load_display = pd.DataFrame(worksheet.get_all_records())
+    load_display.replace('', np.nan, inplace=True)
+    raw_display = load_display.dropna(subset=['Median'])
+    fd_ids = dict(zip(raw_display['Player'], raw_display['player_id']))
+    
+    del load_display
+    del raw_display
 
     return dk_ids, fd_ids
 
@@ -133,31 +115,23 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
     strength_grow_def = strength_grow
     Teams_used_def = Teams_used
     Total_Runs_def = Total_Runs
-    
     while RunsVar <= seed_depth_def:
         if RunsVar <= 3:
             FieldStrength = Strength_var_def
-            RandomPortfolio, maps_dict = get_correlated_portfolio_for_sim(Total_Runs_def * 0.1)
+            RandomPortfolio, maps_dict = get_correlated_portfolio_for_sim(Total_Runs_def * .1)
             FinalPortfolio = RandomPortfolio
-            FinalPortfolio2, maps_dict2 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * 0.1)
-            
-            # Replace pd.concat with pl.vstack
-            FinalPortfolio = pl.vstack([FinalPortfolio, FinalPortfolio2])
-            
+            FinalPortfolio2, maps_dict2 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1)
+            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio2], axis=0)
             maps_dict.update(maps_dict2)
             del FinalPortfolio2
             del maps_dict2
-        elif 3 < RunsVar <= 4:
-            FieldStrength += (strength_grow_def + ((30 - len(Teams_used_def)) * 0.001))
-            FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * 0.1)
-            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * 0.1)
-            
-            # Replace pd.concat with pl.vstack
-            FinalPortfolio = pl.vstack([FinalPortfolio, FinalPortfolio3, FinalPortfolio4])
-            
-            # Replace drop_duplicates and reset_index
-            FinalPortfolio = FinalPortfolio.drop_duplicates(subset=["Projection", "Own"]).sort("index")
-    
+        elif RunsVar > 3 and RunsVar <= 4:
+            FieldStrength += (strength_grow_def + ((30 - len(Teams_used_def)) * .001))
+            FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * .1)
+            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1)
+            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio3], axis=0)
+            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio4], axis=0)
+            FinalPortfolio = FinalPortfolio.drop_duplicates(subset = ['Projection', 'Own'],keep = 'last').reset_index(drop = True)
             maps_dict.update(maps_dict3)
             maps_dict.update(maps_dict4)
             del FinalPortfolio3
@@ -166,95 +140,76 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
             del maps_dict4
         elif RunsVar > 4:
             FieldStrength = 1
-            FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * 0.1)
-            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * 0.1)
-            
-            # Replace pd.concat with pl.vstack
-            FinalPortfolio = pl.vstack([FinalPortfolio, FinalPortfolio3, FinalPortfolio4])
-            
-            # Replace drop_duplicates and reset_index
-            FinalPortfolio = FinalPortfolio.drop_duplicates(subset=["Projection", "Own"]).sort("index")
-            
+            FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * .1)
+            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1)
+            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio3], axis=0)
+            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio4], axis=0)
+            FinalPortfolio = FinalPortfolio.drop_duplicates(subset = ['Projection', 'Own'],keep = 'last').reset_index(drop = True)
             maps_dict.update(maps_dict3)
             maps_dict.update(maps_dict4)
             del FinalPortfolio3
             del maps_dict3
             del FinalPortfolio4
             del maps_dict4
-            
         RunsVar += 1
-
+        
     return FinalPortfolio, maps_dict
 
 def create_stack_options(player_data, wr_var):
-    # Assuming player_data is already a Polars DataFrame
-    # Sort player_data by 'Median' in descending order
-    data_raw = player_data.sort("Median", reverse=True)
-    
-    merged_frame = pl.DataFrame(
-        {
-            "QB": [],
-            "Player": []
-        }
-    )
-    
-    for team in data_raw.select("Team").unique().get("Team"):
-        data_split = data_raw.filter(pl.col("Team") == team)
-        
-        qb_frame = data_split.filter(pl.col("Position") == "QB")
-        wr_frame = data_split.filter(pl.col("Position") == "WR").slice(wr_var - 1, wr_var)
+        merged_frame = pd.DataFrame(columns = ['QB', 'Player'])
+        data_raw = player_data.sort_values(by='Median', ascending=False)
+
+        for team in data_raw['Team'].unique():
+            data_split = data_raw.loc[data_raw['Team'] == team]
+            qb_frame = data_split.loc[data_split['Position'] == 'QB'].reset_index()
+            wr_frame = data_split.loc[data_split['Position'] == 'WR'].iloc[wr_var-1:wr_var]
+            wr_frame['QB'] = qb_frame['Player'][0]
+            merge_slice = wr_frame[['QB', 'Player']]
+            merged_frame = pd.concat([merged_frame, merge_slice])
+        merged_frame = merged_frame.reset_index()
+        correl_dict = dict(zip(merged_frame.QB, merged_frame.Player))
         
-        qb_name = qb_frame.head(1).get("Player")[0] if qb_frame.shape[0] > 0 else None
-        if qb_name is not None:
-            wr_frame = wr_frame.with_column(pl.lit(qb_name).alias("QB"))
-            merge_slice = wr_frame.select("QB", "Player")
-            merged_frame = merged_frame.vstack(merge_slice)
+        del merged_frame
+        del data_raw
     
-    # Reset index (not necessary in Polars as index doesn't exist in the same way as Pandas)
-    # Build a dictionary from the DataFrame
-    correl_dict = dict(zip(merged_frame.get("QB"), merged_frame.get("Player")))
-    
-    del merged_frame
-    del data_raw
-    
-    return correl_dict
-
-@st.cache_data
-def apply_range(s: pl.Series) -> pl.Series:
-    return pl.Series("Var", list(range(s.len())))
+        return correl_dict
 
 def create_overall_dfs(pos_players, table_name, dict_name, pos):
     if pos == "FLEX":
-        pos_players = pos_players.sort("Value", reverse=True)
-        overall_table_name = pos_players.slice(0, round(pos_players.shape[0]))
-        overall_table_name = overall_table_name.with_column(pl.col("Var").apply_range())
-        overall_dict_name = {row[0]: row[1] for row in overall_table_name.select(["Var", "Player"]).collect()}
+        pos_players = pos_players.sort_values(by='Value', ascending=False)
+        table_name_raw = pos_players.reset_index(drop=True)
+        overall_table_name = table_name_raw.head(round(len(table_name_raw)))
+        overall_table_name = overall_table_name.assign(Var = range(0,len(overall_table_name)))
+        overall_dict_name = pd.Series(overall_table_name.Player.values, index=overall_table_name.Var).to_dict()
         
         del pos_players
+        del table_name_raw
     elif pos != "FLEX":
-        table_name_raw = pos_players.filter(pl.col("Position").str_contains(pos))
-        overall_table_name = table_name_raw.slice(0, round(table_name_raw.shape[0]))
-        overall_table_name = overall_table_name.with_column(pl.col("Var").apply_range())
-        overall_dict_name = {row[0]: row[1] for row in overall_table_name.select(["Var", "Player"]).collect()}
+        table_name_raw = pos_players[pos_players['Position'].str.contains(pos)].reset_index(drop=True)
+        overall_table_name = table_name_raw.head(round(len(table_name_raw)))
+        overall_table_name = overall_table_name.assign(Var = range(0,len(overall_table_name)))
+        overall_dict_name = pd.Series(overall_table_name.Player.values, index=overall_table_name.Var).to_dict()
         
         del pos_players
+        del table_name_raw
     
     return overall_table_name, overall_dict_name
 
 
 def get_overall_merged_df():
     ref_dict = {
-        'pos': ['RB', 'WR', 'TE', 'FLEX'],
-        'pos_dfs': ['RB_Table', 'WR_Table', 'TE_Table', 'FLEX_Table'],
-        'pos_dicts': ['rb_dict', 'wr_dict', 'te_dict', 'flex_dict']
-    }
+        'pos':['RB', 'WR', 'TE', 'FLEX'],
+        'pos_dfs':['RB_Table', 'WR_Table', 'TE_Table', 'FLEX_Table'],
+        'pos_dicts':['rb_dict', 'wr_dict', 'te_dict', 'flex_dict']
+        }
     
-    for i in range(0, 4):
-        ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i] = \
+    for i in range(0,4):
+        ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i] =\
             create_overall_dfs(pos_players, ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i], ref_dict['pos'][i])
+        
+    df_out = pd.concat(ref_dict['pos_dfs'], ignore_index=True)
     
-    # Assuming ref_dict['pos_dfs'] is a list of polars.Dataframe
-    df_out = pl.concat(ref_dict['pos_dfs'], rechunk=True)
+    return df_out, ref_dict
 
 def calculate_range_var(count, min_val, FieldStrength, field_growth):
     var = round(len(count[0]) * FieldStrength)
@@ -263,289 +218,297 @@ def calculate_range_var(count, min_val, FieldStrength, field_growth):
     return min(var, len(count[0]))
 
 def create_random_portfolio(Total_Sample_Size, raw_baselines):
-
-    O_merge, full_pos_player_dict = get_overall_merged_df()
-    max_var = len(raw_baselines.filter(pl.col("Position") == "QB"))
-    
-    field_growth_rounded = round(field_growth)
-    ranges_dict = {}
-    
-    # Calculate ranges
-    for df, dict_val, min_val, key in zip(ref_dict['pos_dfs'], ref_dict['pos_dicts'], [10, 20, 30, 10], ['RB', 'WR', 'TE', 'FLEX']):
-        count = create_overall_dfs(pos_players, df, dict_val, key)
-        ranges_dict[f"{key.lower()}_range"] = calculate_range_var(count, min_val, FieldStrength, field_growth_rounded)
     
-    if max_var <= 10:
-        ranges_dict['qb_range'] = round(max_var)
-        ranges_dict['dst_range'] = round(max_var)
-    elif max_var > 10 and max_var <= 16:
-        ranges_dict['qb_range'] = round(max_var / 1.5)
-        ranges_dict['dst_range'] = round(max_var)
-    elif max_var > 16:
-        ranges_dict['qb_range'] = round(max_var / 2)
-        ranges_dict['dst_range'] = round(max_var)
-    
-    # Generate random portfolios
-    rng = np.random.default_rng()
-    total_elements = [1, 2, 3, 1, 1, 1]
-    keys = ['qb', 'rb', 'wr', 'te', 'flex', 'dst']
-    
-    all_choices = [rng.choice(ranges_dict[f"{key}_range"], size=(Total_Sample_Size, elem)) for key, elem in zip(keys, total_elements)]
-    
-    # Create a Polars DataFrame
-    RandomPortfolio = pl.DataFrame(
-        {name: np.hstack([choice[:, i] if choice.shape[1] > i else choice[:, 0] for choice in all_choices]) for i, name in enumerate(['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])}
-    )
-    RandomPortfolio = RandomPortfolio.with_column(pl.col("User/Field").fill_none(0))
-    
-    
-    del O_merge
-
-    return RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict
+            O_merge, full_pos_player_dict = get_overall_merged_df()
+            max_var = len(raw_baselines[raw_baselines['Position'] == 'QB'])
+          
+            field_growth_rounded = round(field_growth)
+            ranges_dict = {}
+            
+            # Calculate ranges
+            for df, dict_val, min_val, key in zip(ref_dict['pos_dfs'], ref_dict['pos_dicts'], [10, 20, 30, 10], ['RB', 'WR', 'TE', 'FLEX']):
+                count = create_overall_dfs(pos_players, df, dict_val, key)
+                ranges_dict[f"{key.lower()}_range"] = calculate_range_var(count, min_val, FieldStrength, field_growth_rounded)
+            if max_var <= 10:
+                ranges_dict['qb_range'] = round(max_var)
+                ranges_dict['dst_range'] = round(max_var)
+            elif max_var > 10 and max_var <= 16:
+                ranges_dict['qb_range'] = round(max_var / 1.5)
+                ranges_dict['dst_range'] = round(max_var)
+            elif max_var > 16:
+                ranges_dict['qb_range'] = round(max_var / 2)
+                ranges_dict['dst_range'] = round(max_var)
+            # Generate unique ranges
+            # for key, value in ranges_dict.items():
+            #     ranges_dict[f"{key}_Uniques"] = list(range(0, value, 1))
+            
+            # Generate random portfolios
+            rng = np.random.default_rng()
+            total_elements = [1, 2, 3, 1, 1, 1]
+            keys = ['qb', 'rb', 'wr', 'te', 'flex', 'dst']
+            
+            all_choices = [rng.choice(ranges_dict[f"{key}_range"], size=(Total_Sample_Size, elem)) for key, elem in zip(keys, total_elements)]
+            RandomPortfolio = pd.DataFrame(np.hstack(all_choices), columns=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+            RandomPortfolio['User/Field'] = 0
+            
+            del O_merge
+          
+            return RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict
 
 def get_correlated_portfolio_for_sim(Total_Sample_Size):
     
     sizesplit = round(Total_Sample_Size * sharp_split)
+    
     RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines)
     stack_num = random.randint(1, 3)
     stacking_dict = create_stack_options(raw_baselines, stack_num)
     
-    # Mapping series
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("QB").apply(lambda x: qb_dict.get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("RB1").apply(lambda x: full_pos_player_dict['pos_dicts'][0].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("RB2").apply(lambda x: full_pos_player_dict['pos_dicts'][0].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("WR1").apply(lambda x: stacking_dict.get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("WR2").apply(lambda x: full_pos_player_dict['pos_dicts'][1].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("WR3").apply(lambda x: full_pos_player_dict['pos_dicts'][1].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("TE").apply(lambda x: full_pos_player_dict['pos_dicts'][2].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("FLEX").apply(lambda x: full_pos_player_dict['pos_dicts'][3].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("DST").apply(lambda x: def_dict.get(x, x), return_dtype=pl.Utf8)
-    )
+    # # Create a dictionary for mapping positions to their corresponding dictionaries
+    # dict_map = {
+    #     'QB': qb_dict,
+    #     'RB1': full_pos_player_dict['pos_dicts'][0],
+    #     'RB2': full_pos_player_dict['pos_dicts'][0],
+    #     'WR1': full_pos_player_dict['pos_dicts'][1],
+    #     'WR2': full_pos_player_dict['pos_dicts'][1],
+    #     'WR3': full_pos_player_dict['pos_dicts'][1],
+    #     'TE': full_pos_player_dict['pos_dicts'][2],
+    #     'FLEX': full_pos_player_dict['pos_dicts'][3],
+    #     'DST': def_dict
+    # }
+    
+    # # Apply mapping for each position
+    # for pos, mapping in dict_map.items():
+    #     RandomPortfolio[pos] = RandomPortfolio[pos].map(mapping).astype("string[pyarrow]")
     
-    # Creating 'plyr_list' and 'plyr_count'
-    plyr_list_exprs = [pl.col(name).alias(f"{name}_item") for name in RandomPortfolio.columns]
-    plyr_list = pl.col(plyr_list_exprs).apply(lambda x: list(set(x)), return_dtype=pl.List(pl.Utf8)).alias("plyr_list")
-    plyr_count = plyr_list.apply(lambda x: len(set(x)), return_dtype=pl.Int64).alias("plyr_count")
+    # # This part appears to be for filtering. Consider if it can be optimized depending on the data characteristics
+    # RandomPortfolio['plyr_list'] = RandomPortfolio.values.tolist()
+    # RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
+    # RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).reset_index(drop=True)
     
-    # Add these to RandomPortfolio
-    RandomPortfolio = RandomPortfolio.with_columns([plyr_list, plyr_count])
+    RandomPortfolio['QB'] = pd.Series(list(RandomPortfolio['QB'].map(qb_dict)), dtype="string[pyarrow]")
+    RandomPortfolio['RB1'] = pd.Series(list(RandomPortfolio['RB1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
+    RandomPortfolio['RB2'] = pd.Series(list(RandomPortfolio['RB2'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
+    RandomPortfolio['WR1'] = pd.Series(list(RandomPortfolio['QB'].map(stacking_dict)), dtype="string[pyarrow]")
+    RandomPortfolio['WR2'] = pd.Series(list(RandomPortfolio['WR2'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
+    RandomPortfolio['WR3'] = pd.Series(list(RandomPortfolio['WR3'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
+    RandomPortfolio['TE'] = pd.Series(list(RandomPortfolio['TE'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX'] = pd.Series(list(RandomPortfolio['FLEX'].map(full_pos_player_dict['pos_dicts'][3])), dtype="string[pyarrow]")
+    RandomPortfolio['DST'] = pd.Series(list(RandomPortfolio['DST'].map(def_dict)), dtype="string[pyarrow]")
+    RandomPortfolio['plyr_list'] = RandomPortfolio[RandomPortfolio.columns.values.tolist()].values.tolist()
+    RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
+    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).\
+        reset_index(drop=True)
     
-    # Filter out rows where 'plyr_count' is not 10
-    RandomPortfolio = RandomPortfolio.filter(pl.col("plyr_count") == 10).select_except("plyr_list", "plyr_count")
+    del sizesplit
+    del full_pos_player_dict
+    del ranges_dict
+    del stack_num
+    del stacking_dict    
     
-    # Since polars DataFrame is lazy, you may want to call .collect() to materialize it
-    RandomPortfolio = RandomPortfolio.collect()
     
-    # Map and cast to specific data types
-    positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
-    for pos in positions:
-        RandomPortfolio = RandomPortfolio.with_column(
-            pl.col(pos).apply(lambda x: maps_dict['Salary_map'].get(x, x), return_dtype=pl.Int32).alias(f"{pos}s")
-        )
-        RandomPortfolio = RandomPortfolio.with_column(
-            pl.col(pos).apply(lambda x: maps_dict['Projection_map'].get(x, x), return_dtype=pl.Float32).alias(f"{pos}p")
-        )
-        RandomPortfolio = RandomPortfolio.with_column(
-            pl.col(pos).apply(lambda x: maps_dict['Own_map'].get(x, x), return_dtype=pl.Float32).alias(f"{pos}o")
-        )
     
-    # Equivalent of converting to numpy array and performing einsum
-    RandomPortfolio = RandomPortfolio.with_columns([
-        pl.sum([pl.col(f"{pos}s") for pos in positions]).alias('Salary'),
-        pl.sum([pl.col(f"{pos}p") for pos in positions]).alias('Projection'),
-        pl.sum([pl.col(f"{pos}o") for pos in positions]).alias('Own')
-    ])
+    RandomPortfolio['QBs'] = RandomPortfolio['QB'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['RB1s'] = RandomPortfolio['RB1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['RB2s'] = RandomPortfolio['RB2'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR1s'] = RandomPortfolio['WR1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR2s'] = RandomPortfolio['WR2'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR3s'] = RandomPortfolio['WR3'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['TEs'] = RandomPortfolio['TE'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEXs'] = RandomPortfolio['FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['DSTs'] = RandomPortfolio['DST'].map(maps_dict['Salary_map']).astype(np.int32)
     
-    # Select the columns you want in the final DataFrame
-    RandomPortfolio = RandomPortfolio.select(
-        positions + ['User/Field', 'Salary', 'Projection', 'Own']
-    )
+    RandomPortfolio['QBp'] = RandomPortfolio['QB'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['RB1p'] = RandomPortfolio['RB1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['RB2p'] = RandomPortfolio['RB2'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR1p'] = RandomPortfolio['WR1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR2p'] = RandomPortfolio['WR2'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR3p'] = RandomPortfolio['WR3'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['TEp'] = RandomPortfolio['TE'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEXp'] = RandomPortfolio['FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['DSTp'] = RandomPortfolio['DST'].map(maps_dict['Projection_map']).astype(np.float16)
     
-    # Since DataFrame is lazy, call collect() to materialize
-    RandomPortfolio = RandomPortfolio.collect()
+    RandomPortfolio['QBo'] = RandomPortfolio['QB'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['RB1o'] = RandomPortfolio['RB1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['RB2o'] = RandomPortfolio['RB2'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR1o'] = RandomPortfolio['WR1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR2o'] = RandomPortfolio['WR2'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR3o'] = RandomPortfolio['WR3'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['TEo'] = RandomPortfolio['TE'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEXo'] = RandomPortfolio['FLEX'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['DSTo'] = RandomPortfolio['DST'].map(maps_dict['Own_map']).astype(np.float16)
     
-    # Sorting based on some function
-    # Note: Replace 'Sim_function' with the actual column name or expression you want to sort by
-    RandomPortfolio = RandomPortfolio.sort('Sim_function', reverse=True)
+    RandomPortArray = RandomPortfolio.to_numpy()
+    del RandomPortfolio
     
-    positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,10:19].astype(int))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,19:28].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,28:37].astype(np.double))]
+    
+    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[10:37], axis=1)
+    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
+    RandomPortfolioDF = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
+    del RandomPortArray
+    del RandomPortArrayOut
     
     if insert_port == 1:
-        CleanPortfolio = CleanPortfolio.with_column(
-            pl.sum([
-                pl.col(pos).apply(lambda x: maps_dict['Salary_map'].get(x, x), return_dtype=pl.Int16)
-                for pos in positions
-            ]).alias('Salary')
-        )
-        
-        CleanPortfolio = CleanPortfolio.with_column(
-            pl.sum([
-                pl.col(pos).apply(lambda x: up_dict['Projection_map'].get(x, x), return_dtype=pl.Float16)
-                for pos in positions
-            ]).alias('Projection')
-        )
-        
-        CleanPortfolio = CleanPortfolio.with_column(
-            pl.sum([
-                pl.col(pos).apply(lambda x: maps_dict['Own_map'].get(x, x), return_dtype=pl.Float16)
-                for pos in positions
-            ]).alias('Own')
-        )
+        CleanPortfolio['Salary'] = sum([CleanPortfolio['QB'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['RB1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['RB2'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['WR1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['WR2'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['WR3'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['TE'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['DST'].map(maps_dict['Salary_map'])
+                                        ]).astype(np.int16)
+    if insert_port == 1:
+        CleanPortfolio['Projection'] = sum([CleanPortfolio['QB'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['RB1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['RB2'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['WR1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['WR2'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['WR3'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['TE'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['DST'].map(up_dict['Projection_map'])
+                                            ]).astype(np.float16)
+    if insert_port == 1:
+        CleanPortfolio['Own'] = sum([CleanPortfolio['QB'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['RB1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['RB2'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['WR1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['WR2'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['WR3'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['TE'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['DST'].map(maps_dict['Own_map'])
+                                    ]).astype(np.float16)
     
     if site_var1 == 'Draftkings':
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 50000)
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (49500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
-    
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 50000].reset_index(drop=True)
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (49500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
     elif site_var1 == 'Fanduel':
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 60000)
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (59500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 60000].reset_index(drop=True)
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (59500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
     
-    # Sorting the DataFrame
-    # Note: Replace 'Sim_function' with the actual column name or expression you want to sort by
-    RandomPortfolioDF = RandomPortfolioDF.sort('Sim_function', reverse=True)
+    RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     
-    # Selecting the columns you want to keep
-    RandomPortfolioDF = RandomPortfolioDF.select(['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
+    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
     
     return RandomPortfolio, maps_dict
           
 def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     
-    sizesplit = round(Total_Sample_Size * sharp_split)
+    sizesplit = round(Total_Sample_Size * (1-sharp_split))
+
     RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines)
-    stack_num = random.randint(1, 3)
-    stacking_dict = create_stack_options(raw_baselines, stack_num)
-    
-    # Mapping series
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("QB").apply(lambda x: qb_dict.get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("RB1").apply(lambda x: full_pos_player_dict['pos_dicts'][0].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("RB2").apply(lambda x: full_pos_player_dict['pos_dicts'][0].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("WR1").apply(lambda x: stacking_dict.get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("WR2").apply(lambda x: full_pos_player_dict['pos_dicts'][1].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("WR3").apply(lambda x: full_pos_player_dict['pos_dicts'][1].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("TE").apply(lambda x: full_pos_player_dict['pos_dicts'][2].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("FLEX").apply(lambda x: full_pos_player_dict['pos_dicts'][3].get(x, x), return_dtype=pl.Utf8)
-    )
-    RandomPortfolio = RandomPortfolio.with_column(
-        pl.col("DST").apply(lambda x: def_dict.get(x, x), return_dtype=pl.Utf8)
-    )
-    
-    # Creating 'plyr_list' and 'plyr_count'
-    plyr_list_exprs = [pl.col(name).alias(f"{name}_item") for name in RandomPortfolio.columns]
-    plyr_list = pl.col(plyr_list_exprs).apply(lambda x: list(set(x)), return_dtype=pl.List(pl.Utf8)).alias("plyr_list")
-    plyr_count = plyr_list.apply(lambda x: len(set(x)), return_dtype=pl.Int64).alias("plyr_count")
-    
-    # Add these to RandomPortfolio
-    RandomPortfolio = RandomPortfolio.with_columns([plyr_list, plyr_count])
-    
-    # Filter out rows where 'plyr_count' is not 10
-    RandomPortfolio = RandomPortfolio.filter(pl.col("plyr_count") == 10).select_except("plyr_list", "plyr_count")
-    
-    # Since polars DataFrame is lazy, you may want to call .collect() to materialize it
-    RandomPortfolio = RandomPortfolio.collect()
+          
+    RandomPortfolio['QB'] = pd.Series(list(RandomPortfolio['QB'].map(qb_dict)), dtype="string[pyarrow]")
+    RandomPortfolio['RB1'] = pd.Series(list(RandomPortfolio['RB1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
+    RandomPortfolio['RB2'] = pd.Series(list(RandomPortfolio['RB2'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
+    RandomPortfolio['WR1'] = pd.Series(list(RandomPortfolio['WR1'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
+    RandomPortfolio['WR2'] = pd.Series(list(RandomPortfolio['WR2'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
+    RandomPortfolio['WR3'] = pd.Series(list(RandomPortfolio['WR3'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
+    RandomPortfolio['TE'] = pd.Series(list(RandomPortfolio['TE'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX'] = pd.Series(list(RandomPortfolio['FLEX'].map(full_pos_player_dict['pos_dicts'][3])), dtype="string[pyarrow]")
+    RandomPortfolio['DST'] = pd.Series(list(RandomPortfolio['DST'].map(def_dict)), dtype="string[pyarrow]")
+    RandomPortfolio['plyr_list'] = RandomPortfolio[RandomPortfolio.columns.values.tolist()].values.tolist()
+    RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
+    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).\
+        reset_index(drop=True)
     
-    # Map and cast to specific data types
-    positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
-    for pos in positions:
-        RandomPortfolio = RandomPortfolio.with_column(
-            pl.col(pos).apply(lambda x: maps_dict['Salary_map'].get(x, x), return_dtype=pl.Int32).alias(f"{pos}s")
-        )
-        RandomPortfolio = RandomPortfolio.with_column(
-            pl.col(pos).apply(lambda x: maps_dict['Projection_map'].get(x, x), return_dtype=pl.Float32).alias(f"{pos}p")
-        )
-        RandomPortfolio = RandomPortfolio.with_column(
-            pl.col(pos).apply(lambda x: maps_dict['Own_map'].get(x, x), return_dtype=pl.Float32).alias(f"{pos}o")
-        )
+    del sizesplit
+    del full_pos_player_dict
+    del ranges_dict
     
-    # Equivalent of converting to numpy array and performing einsum
-    RandomPortfolio = RandomPortfolio.with_columns([
-        pl.sum([pl.col(f"{pos}s") for pos in positions]).alias('Salary'),
-        pl.sum([pl.col(f"{pos}p") for pos in positions]).alias('Projection'),
-        pl.sum([pl.col(f"{pos}o") for pos in positions]).alias('Own')
-    ])
+    RandomPortfolio['QBs'] = RandomPortfolio['QB'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['RB1s'] = RandomPortfolio['RB1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['RB2s'] = RandomPortfolio['RB2'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR1s'] = RandomPortfolio['WR1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR2s'] = RandomPortfolio['WR2'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR3s'] = RandomPortfolio['WR3'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['TEs'] = RandomPortfolio['TE'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEXs'] = RandomPortfolio['FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['DSTs'] = RandomPortfolio['DST'].map(maps_dict['Salary_map']).astype(np.int32)
     
-    # Select the columns you want in the final DataFrame
-    RandomPortfolio = RandomPortfolio.select(
-        positions + ['User/Field', 'Salary', 'Projection', 'Own']
-    )
+    RandomPortfolio['QBp'] = RandomPortfolio['QB'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['RB1p'] = RandomPortfolio['RB1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['RB2p'] = RandomPortfolio['RB2'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR1p'] = RandomPortfolio['WR1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR2p'] = RandomPortfolio['WR2'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR3p'] = RandomPortfolio['WR3'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['TEp'] = RandomPortfolio['TE'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEXp'] = RandomPortfolio['FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['DSTp'] = RandomPortfolio['DST'].map(maps_dict['Projection_map']).astype(np.float16)
     
-    # Since DataFrame is lazy, call collect() to materialize
-    RandomPortfolio = RandomPortfolio.collect()
+    RandomPortfolio['QBo'] = RandomPortfolio['QB'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['RB1o'] = RandomPortfolio['RB1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['RB2o'] = RandomPortfolio['RB2'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR1o'] = RandomPortfolio['WR1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR2o'] = RandomPortfolio['WR2'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR3o'] = RandomPortfolio['WR3'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['TEo'] = RandomPortfolio['TE'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEXo'] = RandomPortfolio['FLEX'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['DSTo'] = RandomPortfolio['DST'].map(maps_dict['Own_map']).astype(np.float16)
     
-    # Sorting based on some function
-    # Note: Replace 'Sim_function' with the actual column name or expression you want to sort by
-    RandomPortfolio = RandomPortfolio.sort('Sim_function', reverse=True)
+    RandomPortArray = RandomPortfolio.to_numpy()
+    del RandomPortfolio
     
-    positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,10:19].astype(int))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,19:28].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,28:37].astype(np.double))]
     
+    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[10:37], axis=1)
+    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
+    RandomPortfolioDF = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
+    del RandomPortArray
+    del RandomPortArrayOut
+    # st.table(RandomPortfolioDF.head(50))
+          
     if insert_port == 1:
-        CleanPortfolio = CleanPortfolio.with_column(
-            pl.sum([
-                pl.col(pos).apply(lambda x: maps_dict['Salary_map'].get(x, x), return_dtype=pl.Int16)
-                for pos in positions
-            ]).alias('Salary')
-        )
-        
-        CleanPortfolio = CleanPortfolio.with_column(
-            pl.sum([
-                pl.col(pos).apply(lambda x: up_dict['Projection_map'].get(x, x), return_dtype=pl.Float16)
-                for pos in positions
-            ]).alias('Projection')
-        )
-        
-        CleanPortfolio = CleanPortfolio.with_column(
-            pl.sum([
-                pl.col(pos).apply(lambda x: maps_dict['Own_map'].get(x, x), return_dtype=pl.Float16)
-                for pos in positions
-            ]).alias('Own')
-        )
+        CleanPortfolio['Salary'] = sum([CleanPortfolio['QB'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['RB1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['RB2'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['WR1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['WR2'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['WR3'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['TE'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['DST'].map(maps_dict['Salary_map'])
+                                        ]).astype(np.int16)
+    if insert_port == 1:
+        CleanPortfolio['Projection'] = sum([CleanPortfolio['QB'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['RB1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['RB2'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['WR1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['WR2'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['WR3'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['TE'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['DST'].map(up_dict['Projection_map'])
+                                            ]).astype(np.float16)
+    if insert_port == 1:
+        CleanPortfolio['Own'] = sum([CleanPortfolio['QB'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['RB1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['RB2'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['WR1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['WR2'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['WR3'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['TE'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['DST'].map(maps_dict['Own_map'])
+                                    ]).astype(np.float16)
     
     if site_var1 == 'Draftkings':
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 50000)
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (49500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
-    
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 50000].reset_index(drop=True)
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (49500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
     elif site_var1 == 'Fanduel':
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 60000)
-        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (59500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 60000].reset_index(drop=True)
+        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (59500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
     
-    # Sorting the DataFrame
-    # Note: Replace 'Sim_function' with the actual column name or expression you want to sort by
-    RandomPortfolioDF = RandomPortfolioDF.sort('Sim_function', reverse=True)
+    RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     
-    # Selecting the columns you want to keep
-    RandomPortfolioDF = RandomPortfolioDF.select(['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
+    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
     
     return RandomPortfolio, maps_dict