Update app.py

app.py

@@ -170,23 +170,37 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
     return FinalPortfolio, maps_dict
 
 def create_stack_options(player_data, 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))
+    # 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)
         
-        del merged_frame
-        del data_raw
+        qb_frame = data_split.filter(pl.col("Position") == "QB")
+        wr_frame = data_split.filter(pl.col("Position") == "WR").slice(wr_var - 1, wr_var)
+        
+        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)
+    
+    # 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
+    return correl_dict
 
 @st.cache_data
 def apply_range(s: pl.Series) -> pl.Series:
@@ -275,257 +289,246 @@ def create_random_portfolio(Total_Sample_Size, raw_baselines):
 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)
     
-    # # 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]")
-    
-    # # 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)
+    # 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)
+    )
     
-    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)
+    # 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")
     
-    del sizesplit
-    del full_pos_player_dict
-    del ranges_dict
-    del stack_num
-    del stacking_dict    
+    # 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['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)
+    # 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")
+        )
     
-    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)
+    # 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['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)
+    # Select the columns you want in the final DataFrame
+    RandomPortfolio = RandomPortfolio.select(
+        positions + ['User/Field', 'Salary', 'Projection', 'Own']
+    )
     
-    RandomPortArray = RandomPortfolio.to_numpy()
-    del RandomPortfolio
+    # Since DataFrame is lazy, call collect() to materialize
+    RandomPortfolio = RandomPortfolio.collect()
     
-    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))]
+    # 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)
     
-    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
+    positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
     
     if insert_port == 1:
-        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)
+        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')
+        )
     
     if site_var1 == 'Draftkings':
-        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)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 50000)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (49500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
+    
     elif site_var1 == 'Fanduel':
-        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)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 60000)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (59500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
     
-    RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
+    # 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 = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
+    # Selecting the columns you want to keep
+    RandomPortfolioDF = RandomPortfolioDF.select(['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 * (1-sharp_split))
-
+    sizesplit = round(Total_Sample_Size * sharp_split)
     RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines)
-          
-    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)
+    stack_num = random.randint(1, 3)
+    stacking_dict = create_stack_options(raw_baselines, stack_num)
     
-    del sizesplit
-    del full_pos_player_dict
-    del ranges_dict
+    # 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)
+    )
     
-    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)
+    # 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")
     
-    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)
+    # Add these to RandomPortfolio
+    RandomPortfolio = RandomPortfolio.with_columns([plyr_list, plyr_count])
     
-    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)
+    # Filter out rows where 'plyr_count' is not 10
+    RandomPortfolio = RandomPortfolio.filter(pl.col("plyr_count") == 10).select_except("plyr_list", "plyr_count")
     
-    RandomPortArray = RandomPortfolio.to_numpy()
-    del RandomPortfolio
+    # Since polars DataFrame is lazy, you may want to call .collect() to materialize it
+    RandomPortfolio = RandomPortfolio.collect()
     
-    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))]
+    # 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')
+    ])
+    
+    # Select the columns you want in the final DataFrame
+    RandomPortfolio = RandomPortfolio.select(
+        positions + ['User/Field', 'Salary', 'Projection', 'Own']
+    )
+    
+    # Since DataFrame is lazy, call collect() to materialize
+    RandomPortfolio = RandomPortfolio.collect()
+    
+    # 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)
+    
+    positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
     
-    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['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)
+        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')
+        )
     
     if site_var1 == 'Draftkings':
-        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)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 50000)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (49500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
+    
     elif site_var1 == 'Fanduel':
-        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)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') <= 60000)
+        RandomPortfolioDF = RandomPortfolioDF.filter(pl.col('Salary') >= (59500 - (5000 * (1 - (len(Teams_used) / 32))) - (FieldStrength * 1000)))
     
-    RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
+    # 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 = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
+    # Selecting the columns you want to keep
+    RandomPortfolioDF = RandomPortfolioDF.select(['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
     
     return RandomPortfolio, maps_dict