Initial Commit

global_func/clean_player_name.py

@@ -0,0 +1,16 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+def clean_player_name(name):
+    # Handle colon case first (remove everything before colon)
+    if ':' in name:
+        name = name.split(':')[1].strip()
+    
+    # Handle parentheses case (remove everything after opening parenthesis)
+    if '(' in name:
+        name = name.split('(')[0].strip()
+    
+    return name

global_func/find_csv_mismatches.py

@@ -0,0 +1,93 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+from fuzzywuzzy import process
+
+def find_csv_mismatches(csv_df, projections_df):
+    # Create copies of the dataframes to avoid modifying the originals
+    csv_df = csv_df.copy()
+    projections_df = projections_df.copy()
+    
+    if 'Name' not in csv_df.columns:
+        st.error("No 'Name' column found in CSV file")
+        return csv_df
+        
+    if 'player_names' not in projections_df.columns:
+        st.error("No 'player_names' column found in projections file")
+        return csv_df
+    
+    # Get unique player names from CSV and projections
+    csv_players = set(csv_df['Name'].dropna().unique())
+    projection_players = set(projections_df['player_names'].unique())
+    projection_players_list = list(csv_players)
+    
+    # Find players in CSV that are missing from projections
+    players_missing_from_projections = list(projection_players - csv_players)
+    
+    # Automatically handle 100% matches before starting interactive process
+    players_to_process = []
+    for player in players_missing_from_projections:
+        if not isinstance(player, str):
+            st.warning(f"Skipping non-string value: {player}")
+            continue
+        closest_matches = process.extract(player, projection_players_list, limit=1)
+        if closest_matches[0][1] == 100:  # If perfect match found
+            match_name = closest_matches[0][0]
+            # Update CSV DataFrame to use the projection name
+            csv_df.loc[csv_df['Name'] == player, 'Name'] = match_name
+            st.success(f"Automatically matched '{player}' with '{match_name}' (100% match)")
+        else:
+            players_to_process.append(player)
+    
+    # Initialize session state for tracking current player if not exists
+    if 'csv_current_player_index' not in st.session_state:
+        st.session_state.csv_current_player_index = 0
+        st.session_state.csv_players_to_process = players_to_process
+    
+    # Display results
+    if players_missing_from_projections:
+        st.warning("Players in CSV but missing from projections")
+        
+        # Display remaining players
+        remaining_players = st.session_state.csv_players_to_process[st.session_state.csv_current_player_index:]
+        st.info(f"Remaining players to process ({len(remaining_players)}):\n" + 
+                "\n".join(f"- {player}" for player in remaining_players))
+        
+        if st.session_state.csv_current_player_index < len(st.session_state.csv_players_to_process):
+            current_player = st.session_state.csv_players_to_process[st.session_state.csv_current_player_index]
+            
+            # Find the top 3 closest matches
+            closest_matches = process.extract(current_player, projection_players_list, limit=3)
+            
+            st.write(f"**Missing Player {st.session_state.csv_current_player_index + 1} of {len(st.session_state.csv_players_to_process)}:** {current_player}")
+            
+            # Create radio buttons for selection
+            options = [f"{match[0]} ({match[1]}%)" for match in closest_matches]
+            options.append("None of these")
+            
+            selected_option = st.radio(
+                f"Select correct match:",
+                options,
+                key=f"csv_radio_{current_player}"
+            )
+            
+            if st.button("Confirm Selection", key="csv_confirm"):
+                if selected_option != "None of these":
+                    selected_name = selected_option.split(" (")[0]
+                    # Update CSV DataFrame
+                    csv_df.loc[csv_df['Name'] == current_player, 'Name'] = selected_name
+                    st.success(f"Replaced '{current_player}' with '{selected_name}'")
+                    st.session_state['csv_file'] = csv_df
+                
+                # Move to next player
+                st.session_state.csv_current_player_index += 1
+                st.rerun()
+        else:
+            st.success("All players have been processed!")
+            # Reset the index for future runs
+            st.session_state.csv_current_player_index = 0
+            st.session_state.csv_players_to_process = []
+    else:
+        st.success("All CSV players found in projections!")
+    
+    return csv_df

global_func/find_name_mismatches.py

@@ -0,0 +1,92 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+def find_name_mismatches(portfolio_df, projections_df):
+    """
+    Find and handle name mismatches between portfolio and projections dataframes.
+    Returns the updated projections dataframe with matched names.
+    """
+    # Get all player names from portfolio
+    portfolio_players = set()
+    for col in portfolio_df.columns:
+        if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Win%', 'Lineup Edge']:
+            portfolio_players.update(portfolio_df[col].unique())
+    
+    # Get all player names from projections
+    projection_players_list = projections_df['player_names'].tolist()
+    
+    # Find players in portfolio that are missing from projections
+    players_missing_from_projections = [player for player in portfolio_players if player not in projection_players_list]
+    
+    # Automatically handle 100% matches before starting interactive process
+    players_to_process = []
+    for player in players_missing_from_projections:
+        if not isinstance(player, str):
+            st.warning(f"Skipping non-string value: {player}")
+            continue
+        closest_matches = process.extract(player, projection_players_list, limit=1)
+        if closest_matches[0][1] == 90:  # If perfect match found
+            match_name = closest_matches[0][0]
+            projections_df.loc[projections_df['player_names'] == match_name, 'player_names'] = player
+            st.success(f"Automatically matched '{match_name}' with '{player}' (100% match)")
+        else:
+            players_to_process.append(player)
+    
+    # Display results
+    if players_missing_from_projections:
+        st.warning("Players in portfolio but missing from projections")
+        
+        # Display remaining players
+        if players_to_process:
+            st.info(f"Players to process ({len(players_to_process)}):\n" + 
+                    "\n".join(f"- {player}" for player in players_to_process))
+            
+            # Create a form for batch processing
+            with st.form("player_matching_form"):
+                # Create tabs for each player
+                tabs = st.tabs([f"Player {i+1}" for i in range(len(players_to_process))])
+                
+                # Dictionary to store selections
+                selections = {}
+                
+                # Process each tab
+                for idx, (tab, player) in enumerate(zip(tabs, players_to_process)):
+                    with tab:
+                        st.write(f"**Missing Player {idx + 1} of {len(players_to_process)}:** {player}")
+                        
+                        # Find the top 3 closest matches
+                        closest_matches = process.extract(player, projection_players_list, limit=3)
+                        
+                        # Create radio buttons for selection
+                        options = [f"{match[0]} ({match[1]}%)" for match in closest_matches]
+                        options.append("None of these")
+                        
+                        selected_option = st.radio(
+                            f"Select correct match for {player}:",
+                            options,
+                            key=f"radio_{player}"
+                        )
+                        
+                        selections[player] = selected_option
+                
+                # Submit button for the entire form
+                submitted = st.form_submit_button("Submit All Changes")
+                
+                if submitted:
+                    # Process all selections
+                    for player, selection in selections.items():
+                        if selection != "None of these":
+                            selected_name = selection.split(" (")[0]
+                            projections_df.loc[projections_df['player_names'] == selected_name, 'player_names'] = player
+                            st.success(f"Replaced '{selected_name}' with '{player}'")
+                    
+                    # Update session state
+                    st.session_state['projections_df'] = projections_df
+                    st.success("All player name changes have been applied!")
+    else:
+        st.success("All portfolio players found in projections!")
+    
+    return projections_df

global_func/highlight_rows.py

@@ -0,0 +1,29 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+def highlight_changes(row):
+    original_row = st.session_state['portfolio'].iloc[row.name]
+    colors = [''] * len(row)
+    for i, (orig, new) in enumerate(zip(original_row, row)):
+        if orig != new:
+            colors[i] = 'background-color: yellow'
+    return colors
+
+def highlight_changes_winners(row):
+    original_row = st.session_state['optimized_df_medians'].iloc[row.name]
+    colors = [''] * len(row)
+    for i, (orig, new) in enumerate(zip(original_row, row)):
+        if orig != new:
+            colors[i] = 'background-color: aqua'
+    return colors
+
+def highlight_changes_losers(row):
+    original_row = st.session_state['optimized_df_winners'].iloc[row.name]
+    colors = [''] * len(row)
+    for i, (orig, new) in enumerate(zip(original_row, row)):
+        if orig != new:
+            colors[i] = 'background-color: darksalmon'
+    return colors

global_func/load_csv.py

@@ -0,0 +1,24 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+def load_csv(upload):
+    if upload is not None:
+        try:
+            if upload.name.endswith('.csv'):
+                df = pd.read_csv(upload)
+                try:
+                    df['Name + ID'] = df['Name'] + ' (' + df['ID'].astype(str) + ')'
+                except:
+                    pass
+            else:
+                st.error('Please upload either a CSV or Excel file')
+                return None
+            
+            return df
+        except Exception as e:
+            st.error(f'Error loading file: {str(e)}')
+            return None
+    return None

global_func/load_file.py

@@ -0,0 +1,31 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+## import global functions
+from global_func.clean_player_name import clean_player_name
+
+def load_file(upload):
+    if upload is not None:
+        try:
+            if upload.name.endswith('.csv'):
+                df = pd.read_csv(upload)
+            elif upload.name.endswith(('.xls', '.xlsx')):
+                df = pd.read_excel(upload)
+            else:
+                st.error('Please upload either a CSV or Excel file')
+                return None
+            
+            export_df = df.copy()
+            
+            for col in df.columns:
+                if df[col].dtype == 'object':
+                    df[col] = df[col].apply(lambda x: clean_player_name(x) if isinstance(x, str) else x)
+            
+            return export_df, df
+        except Exception as e:
+            st.error(f'Error loading file: {str(e)}')
+            return None
+    return None

global_func/load_ss_file.py

@@ -0,0 +1,34 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+def load_ss_file(lineups, csv_file):
+    df = csv_file.copy()
+    try:
+        name_dict = dict(zip(df['ID'], df['Name']))
+    except:
+        name_dict = dict(zip(df['Id'], df['Nickname']))
+
+    # Now load and process the lineups file
+    try:
+        if lineups.name.endswith('.csv'):
+            lineups_df = pd.read_csv(lineups)
+        elif lineups.name.endswith(('.xls', '.xlsx')):
+            lineups_df = pd.read_excel(lineups)
+        else:
+            st.error('Please upload either a CSV or Excel file for lineups')
+            return None, None
+        
+        export_df = lineups_df.copy()
+        
+        # Map the IDs to names
+        for col in lineups_df.columns:
+            lineups_df[col] = lineups_df[col].map(name_dict)
+        
+        return export_df, lineups_df
+        
+    except Exception as e:
+        st.error(f'Error loading lineups file: {str(e)}')
+        return None, None

global_func/optimize_lineup.py

@@ -0,0 +1,74 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+def optimize_lineup(row):
+    current_lineup = []
+    total_salary = 0
+    salary_cap = 50000
+    used_players = set()
+
+    # Convert row to dictionary with roster positions
+    roster = {}
+    for col, player in zip(row.index, row):
+        if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
+            roster[col] = {
+                'name': player,
+                'position': map_dict['pos_map'].get(player, '').split('/'),
+                'team': map_dict['team_map'].get(player, ''),
+                'salary': map_dict['salary_map'].get(player, 0),
+                'median': map_dict['proj_map'].get(player, 0),
+                'ownership': map_dict['own_map'].get(player, 0)
+            }
+            total_salary += roster[col]['salary']
+            used_players.add(player)
+
+    # Optimize each roster position in random order
+    roster_positions = list(roster.items())
+    random.shuffle(roster_positions)
+    
+    for roster_pos, current in roster_positions:
+        # Skip optimization for players from removed teams
+        if current['team'] in remove_teams_var:
+            continue
+        
+        valid_positions = position_rules[roster_pos]
+        better_options = []
+
+        # Find valid replacements for this roster position
+        for pos in valid_positions:
+            if pos in position_groups:
+                pos_options = [
+                    p for p in position_groups[pos]
+                    if p['median'] > current['median']
+                    and (total_salary - current['salary'] + p['salary']) <= salary_cap
+                    and p['player_names'] not in used_players
+                    and any(valid_pos in p['positions'] for valid_pos in valid_positions)
+                    and map_dict['team_map'].get(p['player_names']) not in remove_teams_var  # Check team restriction
+                ]
+                better_options.extend(pos_options)
+
+        if better_options:
+            # Remove duplicates
+            better_options = {opt['player_names']: opt for opt in better_options}.values()
+            
+            # Sort by median projection and take the best one
+            best_replacement = max(better_options, key=lambda x: x['median'])
+            
+            # Update the lineup and tracking variables
+            used_players.remove(current['name'])
+            used_players.add(best_replacement['player_names'])
+            total_salary = total_salary - current['salary'] + best_replacement['salary']
+            roster[roster_pos] = {
+                'name': best_replacement['player_names'],
+                'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
+                'team': map_dict['team_map'][best_replacement['player_names']],
+                'salary': best_replacement['salary'],
+                'median': best_replacement['median'],
+                'ownership': best_replacement['ownership']
+            }
+
+    # Return optimized lineup maintaining original column order
+    return [roster[pos]['name'] for pos in row.index if pos in roster]

global_func/predict_dupes.py

@@ -0,0 +1,188 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import time
+from fuzzywuzzy import process
+
+def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, strength_var):
+    if strength_var == 'Weak':
+        dupes_multiplier = .75
+        percentile_multiplier = .90
+    elif strength_var == 'Average':
+        dupes_multiplier = 1.00
+        percentile_multiplier = 1.00
+    elif strength_var == 'Sharp':
+        dupes_multiplier = 1.25
+        percentile_multiplier = 1.10
+    max_ownership = max(maps_dict['own_map'].values()) / 100
+    average_ownership = np.mean(list(maps_dict['own_map'].values())) / 100
+    if site_var == 'Fanduel':
+        if type_var == 'Showdown':
+            dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank']
+            own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own']
+            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            flex_ownerships = pd.concat([
+                portfolio.iloc[:,1].map(maps_dict['own_map']),
+                portfolio.iloc[:,2].map(maps_dict['own_map']),
+                portfolio.iloc[:,3].map(maps_dict['own_map']),
+                portfolio.iloc[:,4].map(maps_dict['own_map'])
+            ])
+            flex_rank = flex_ownerships.rank(pct=True)
+            
+            # Assign ranks back to individual columns using the same rank scale
+            portfolio['CPT_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).rank(pct=True)
+            portfolio['FLEX1_Own_percent_rank'] = portfolio.iloc[:,1].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX2_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX3_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX4_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+
+            portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']) / 100
+            portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']) / 100
+            portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']) / 100
+            portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']) / 100
+            portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']) / 100
+            
+            portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+            portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
+            portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
+            portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
+            
+            # Calculate dupes formula
+            portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (60000 - portfolio['Own'])) / 100) - ((60000 - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier
+            
+            # Round and handle negative values
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['dupes_calc'], 0) <= 0,
+                0, 
+                np.round(portfolio['dupes_calc'], 0) - 1
+            )
+        if type_var == 'Classic':
+            num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
+            dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
+            own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
+            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            for i in range(1, num_players + 1):
+                portfolio[f'player_{i}_percent_rank'] = portfolio.iloc[:,i-1].map(maps_dict['own_percent_rank'])
+                portfolio[f'player_{i}_own'] = portfolio.iloc[:,i-1].map(maps_dict['own_map']) / 100
+            
+            portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+            portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
+            portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
+            portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
+            
+            portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (60000 - portfolio['Own'])) / 100) - ((60000 - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier
+            # Round and handle negative values
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['dupes_calc'], 0) <= 0,
+                0, 
+                np.round(portfolio['dupes_calc'], 0) - 1
+            )
+
+    elif site_var == 'Draftkings':
+        if type_var == 'Showdown':
+            dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank']
+            own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own']
+            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            flex_ownerships = pd.concat([
+                portfolio.iloc[:,1].map(maps_dict['own_map']),
+                portfolio.iloc[:,2].map(maps_dict['own_map']),
+                portfolio.iloc[:,3].map(maps_dict['own_map']),
+                portfolio.iloc[:,4].map(maps_dict['own_map']),
+                portfolio.iloc[:,5].map(maps_dict['own_map'])
+            ])
+            flex_rank = flex_ownerships.rank(pct=True)
+            
+            # Assign ranks back to individual columns using the same rank scale
+            portfolio['CPT_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).rank(pct=True)
+            portfolio['FLEX1_Own_percent_rank'] = portfolio.iloc[:,1].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX2_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX3_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX4_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX5_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+
+            portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']) / 100
+            portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']) / 100
+            portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']) / 100
+            portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']) / 100
+            portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']) / 100
+            portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']) / 100
+
+            portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+            portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
+            portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
+            portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
+            
+            # Calculate dupes formula
+            portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((50000 - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier
+
+            # Round and handle negative values
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['dupes_calc'], 0) <= 0,
+                0, 
+                np.round(portfolio['dupes_calc'], 0) - 1
+            )
+        if type_var == 'Classic':
+            num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
+            dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
+            own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
+            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            for i in range(1, num_players + 1):
+                portfolio[f'player_{i}_percent_rank'] = portfolio.iloc[:,i-1].map(maps_dict['own_percent_rank'])
+                portfolio[f'player_{i}_own'] = portfolio.iloc[:,i-1].map(maps_dict['own_map']) / 100
+            
+            portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+            portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
+            portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
+            portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
+            
+            portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((50000 - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier
+            # Round and handle negative values
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['dupes_calc'], 0) <= 0,
+                0, 
+                np.round(portfolio['dupes_calc'], 0) - 1
+            )
+
+    portfolio['Dupes'] = np.round(portfolio['Dupes'], 0)
+    portfolio['own_ratio'] = np.where(
+        portfolio[own_columns].isin([max_ownership]).any(axis=1),
+        portfolio['own_sum'] / portfolio['own_average'],
+        (portfolio['own_sum'] - max_ownership) / portfolio['own_average']
+    )
+    percentile_cut_scalar = portfolio['median'].max()  # Get scalar value
+    if type_var == 'Classic':
+        own_ratio_nerf = 2
+    elif type_var == 'Showdown':
+        own_ratio_nerf = 1.5
+    portfolio['Finish_percentile'] = portfolio.apply(
+        lambda row: .0005 if (row['own_ratio'] - own_ratio_nerf) / ((10 * (row['median'] / percentile_cut_scalar)) / 2) < .0005 
+        else (row['own_ratio'] - own_ratio_nerf) / ((10 * (row['median'] / percentile_cut_scalar)) / 2), 
+        axis=1
+    )
+    
+    portfolio['Ref_Proj'] = portfolio['median'].max()
+    portfolio['Max_Proj'] = portfolio['Ref_Proj'] + 10
+    portfolio['Min_Proj'] = portfolio['Ref_Proj'] - 10
+    portfolio['Avg_Ref'] = (portfolio['Max_Proj'] + portfolio['Min_Proj']) / 2
+    portfolio['Win%'] = (((portfolio['median'] / portfolio['Avg_Ref']) - (0.1 + ((portfolio['Ref_Proj'] - portfolio['median'])/100))) / (Contest_Size / 1000)) / 10
+    max_allowed_win = (1 / Contest_Size) * 5
+    portfolio['Win%'] = portfolio['Win%'] / portfolio['Win%'].max() * max_allowed_win
+    
+    portfolio['Finish_percentile'] = portfolio['Finish_percentile'] + .005 + (.005 * (Contest_Size / 10000))
+    portfolio['Finish_percentile'] = portfolio['Finish_percentile'] * percentile_multiplier
+    portfolio['Win%'] = portfolio['Win%'] * (1 - portfolio['Finish_percentile'])
+    
+    portfolio['low_own_count'] = portfolio[own_columns].apply(lambda row: (row < 0.10).sum(), axis=1)
+    portfolio['Finish_percentile'] = portfolio.apply(lambda row: row['Finish_percentile'] if row['low_own_count'] <= 0 else row['Finish_percentile'] / row['low_own_count'], axis=1)
+    portfolio['Lineup Edge'] = portfolio['Win%'] * ((.5 - portfolio['Finish_percentile']) * (Contest_Size / 2.5))
+    portfolio['Lineup Edge'] = portfolio.apply(lambda row: row['Lineup Edge'] / (row['Dupes'] + 1) if row['Dupes'] > 0 else row['Lineup Edge'], axis=1)
+    portfolio['Lineup Edge'] = portfolio['Lineup Edge'] - portfolio['Lineup Edge'].mean()
+    portfolio = portfolio.drop(columns=dup_count_columns)
+    portfolio = portfolio.drop(columns=own_columns)
+    portfolio = portfolio.drop(columns=calc_columns)
+
+    return portfolio