Add functionality for player name cleaning and CSV mismatch detection

- Updated `app.py` to remove the "Late Swap" tab and simplify the interface.
- Introduced new functions in `global_func`:
- `clean_player_name.py`: Cleans player names by removing unnecessary characters.
- `find_csv_mismatches.py`: Identifies mismatches between uploaded CSV files and projections.
- `find_name_mismatches.py`: Detects name mismatches in player portfolios.
- `highlight_rows.py`: Adds functionality to highlight changes in dataframes.
- `load_csv.py`, `load_file.py`, `load_ss_file.py`: Functions for loading CSV and Excel files with error handling.
- `optimize_lineup.py`: Optimizes player lineups based on various criteria.
- `predict_dupes.py`: Predicts duplicate players in lineups based on ownership and contest size.
- Enhanced user experience with improved error messages and data handling.

app.py

@@ -20,7 +20,7 @@ freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '
 player_wrong_names_mlb = ['Enrique Hernandez']
 player_right_names_mlb = ['Kike Hernandez']
 
-tab1, tab2, tab3 = st.tabs(["Data Load", "Late Swap", "Manage Portfolio"])
+tab1, tab2 = st.tabs(["Data Load", "Contest Analysis"])
 with tab1:
     if st.button('Clear data', key='reset1'):
         st.session_state.clear()
@@ -29,7 +29,7 @@ with tab1:
 
     with col1:
         st.subheader("Draftkings/Fanduel CSV")
-        st.info("Upload the player pricing CSV from the site you are playing on. This is used in late swap exporting and/or with SaberSim portfolios, but is not necessary for the portfolio management functions.")
+        st.info("Upload the player pricing CSV from the site you are playing on.")
 
         upload_csv_col, csv_template_col = st.columns([3, 1])
         with upload_csv_col:
@@ -169,518 +169,6 @@ with tab1:
                     st.session_state['export_dict'] = dict(zip(projections['player_names'], projections['upload_match']))
 
 with tab2:
-    if st.button('Clear data', key='reset2'):
-        st.session_state.clear()
-    
-    if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
-
-        optimized_df = None
-
-        map_dict = {
-                    'pos_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                    st.session_state['projections_df']['position'])),
-                    'salary_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                        st.session_state['projections_df']['salary'])),
-                    'proj_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                    st.session_state['projections_df']['median'])),
-                    'own_map': dict(zip(st.session_state['projections_df']['player_names'],
-                                    st.session_state['projections_df']['ownership'])),
-                    'team_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                        st.session_state['projections_df']['team']))
-                }
-        # Calculate new stats for optimized lineups
-        st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
-            lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
-        )
-        st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
-            lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
-        )
-
-        st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
-            lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
-        )
-
-        options_container = st.container()
-        with options_container:
-            col1, col2, col3, col4, col5, col6 = st.columns(6)
-            with col1:
-                curr_site_var = st.selectbox("Select your current site", options=['DraftKings', 'FanDuel'])
-            with col2:
-                curr_sport_var = st.selectbox("Select your current sport", options=['NBA', 'MLB', 'NFL', 'NHL', 'MMA'])
-            with col3:
-                swap_var = st.multiselect("Select late swap strategy", options=['Optimize', 'Increase volatility', 'Decrease volatility'])
-            with col4:
-                remove_teams_var = st.multiselect("What teams have already played?", options=st.session_state['projections_df']['team'].unique())
-            with col5:
-                winners_var = st.multiselect("Are there any players doing exceptionally well?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3)
-            with col6:
-                losers_var = st.multiselect("Are there any players doing exceptionally poorly?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3)
-        if st.button('Clear Late Swap'):
-            if 'optimized_df' in st.session_state:
-                del st.session_state['optimized_df']
-
-            map_dict = {
-                        'pos_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                        st.session_state['projections_df']['position'])),
-                        'salary_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                            st.session_state['projections_df']['salary'])),
-                        'proj_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                        st.session_state['projections_df']['median'])),
-                        'own_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                        st.session_state['projections_df']['ownership'])),
-                        'team_map': dict(zip(st.session_state['projections_df']['player_names'], 
-                                        st.session_state['projections_df']['team']))
-                    }
-            # Calculate new stats for optimized lineups
-            st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
-                lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
-            )
-            st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
-                lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
-            )
-            st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
-                lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
-            )
-
-        if st.button('Run Late Swap'):
-            st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['salary', 'median', 'Own'])
-            if curr_sport_var == 'NBA':
-                if curr_site_var == 'DraftKings':
-                    st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'UTIL'], axis=1)
-                else:
-                    st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'PG', 'SG', 'SG', 'SF', 'SF', 'PF', 'PF', 'C'], axis=1)
-            
-            # Define roster position rules
-            if curr_site_var == 'DraftKings':
-                position_rules = {
-                    'PG': ['PG'],
-                    'SG': ['SG'],
-                    'SF': ['SF'],
-                    'PF': ['PF'],
-                    'C': ['C'],
-                    'G': ['PG', 'SG'],
-                    'F': ['SF', 'PF'],
-                    'UTIL': ['PG', 'SG', 'SF', 'PF', 'C']
-                    }
-            else:
-                position_rules = {
-                    'PG': ['PG'],
-                    'SG': ['SG'],
-                    'SF': ['SF'],
-                    'PF': ['PF'],
-                    'C': ['C'],
-                }
-            # Create position groups from projections data
-            position_groups = {}
-            for _, player in st.session_state['projections_df'].iterrows():
-                positions = player['position'].split('/')
-                for pos in positions:
-                    if pos not in position_groups:
-                        position_groups[pos] = []
-                    position_groups[pos].append({
-                        'player_names': player['player_names'],
-                        'salary': player['salary'],
-                        'median': player['median'],
-                        'ownership': player['ownership'],
-                        'positions': positions  # Store all eligible positions
-                    })
-
-            def optimize_lineup(row):
-                current_lineup = []
-                total_salary = 0
-                if curr_site_var == 'DraftKings':
-                    salary_cap = 50000
-                else:
-                    salary_cap = 60000
-                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]
-
-            def optimize_lineup_winners(row):
-                current_lineup = []
-                total_salary = 0
-                if curr_site_var == 'DraftKings':
-                    salary_cap = 50000
-                else:
-                    salary_cap = 60000
-                used_players = set()
-
-                # Check if any winners are in the lineup and count them
-                winners_in_lineup = sum(1 for player in row if player in winners_var)
-                changes_needed = min(winners_in_lineup, 3) if winners_in_lineup > 0 else 0
-                changes_made = 0
-
-                # 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)
-
-                # Only proceed with ownership-based optimization if we have winners in the lineup
-                if changes_needed > 0:
-                    # Randomize the order of positions to optimize
-                    roster_positions = list(roster.items())
-                    random.shuffle(roster_positions)
-                    
-                    for roster_pos, current in roster_positions:
-                        # Stop if we've made enough changes
-                        if changes_made >= changes_needed:
-                            break
-                            
-                        # Skip optimization for players from removed teams or if the current player is a winner
-                        if current['team'] in remove_teams_var or current['name'] in winners_var:
-                            continue
-                        
-                        valid_positions = list(position_rules[roster_pos])
-                        random.shuffle(valid_positions)
-                        better_options = []
-
-                        # Find valid replacements with higher ownership
-                        for pos in valid_positions:
-                            if pos in position_groups:
-                                pos_options = [
-                                    p for p in position_groups[pos]
-                                    if p['ownership'] > current['ownership']
-                                    and p['median'] >= current['median'] - 3
-                                    and (total_salary - current['salary'] + p['salary']) <= salary_cap
-                                    and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000
-                                    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
-                                ]
-                                better_options.extend(pos_options)
-
-                        if better_options:
-                            # Remove duplicates
-                            better_options = {opt['player_names']: opt for opt in better_options}.values()
-                            
-                            # Sort by ownership and take the highest owned option
-                            best_replacement = max(better_options, key=lambda x: x['ownership'])
-                            
-                            # 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']
-                            }
-                            changes_made += 1
-
-                # Return optimized lineup maintaining original column order
-                return [roster[pos]['name'] for pos in row.index if pos in roster]
-            
-            def optimize_lineup_losers(row):
-                current_lineup = []
-                total_salary = 0
-                if curr_site_var == 'DraftKings':
-                    salary_cap = 50000
-                else:
-                    salary_cap = 60000
-                used_players = set()
-
-                # Check if any winners are in the lineup and count them
-                losers_in_lineup = sum(1 for player in row if player in losers_var)
-                changes_needed = min(losers_in_lineup, 3) if losers_in_lineup > 0 else 0
-                changes_made = 0
-
-                # 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)
-
-                # Only proceed with ownership-based optimization if we have winners in the lineup
-                if changes_needed > 0:
-                    # Randomize the order of positions to optimize
-                    roster_positions = list(roster.items())
-                    random.shuffle(roster_positions)
-                    
-                    for roster_pos, current in roster_positions:
-                        # Stop if we've made enough changes
-                        if changes_made >= changes_needed:
-                            break
-                            
-                        # Skip optimization for players from removed teams or if the current player is a winner
-                        if current['team'] in remove_teams_var or current['name'] in losers_var:
-                            continue
-                        
-                        valid_positions = list(position_rules[roster_pos])
-                        random.shuffle(valid_positions)
-                        better_options = []
-
-                        # Find valid replacements with higher ownership
-                        for pos in valid_positions:
-                            if pos in position_groups:
-                                pos_options = [
-                                    p for p in position_groups[pos]
-                                    if p['ownership'] < current['ownership']
-                                    and p['median'] >= current['median'] - 3
-                                    and (total_salary - current['salary'] + p['salary']) <= salary_cap
-                                    and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000
-                                    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
-                                ]
-                                better_options.extend(pos_options)
-
-                        if better_options:
-                            # Remove duplicates
-                            better_options = {opt['player_names']: opt for opt in better_options}.values()
-                            
-                            # Sort by ownership and take the highest owned option
-                            best_replacement = max(better_options, key=lambda x: x['ownership'])
-                            
-                            # 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']
-                            }
-                            changes_made += 1
-
-                # Return optimized lineup maintaining original column order
-                return [roster[pos]['name'] for pos in row.index if pos in roster]
-
-            # Create a progress bar
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            
-            # Process each lineup
-            optimized_lineups = []
-            total_lineups = len(st.session_state['portfolio'])
-            
-            for idx, row in st.session_state['portfolio'].iterrows():
-                # First optimization pass
-                first_pass = optimize_lineup(row)
-                first_pass_series = pd.Series(first_pass, index=row.index)
-
-                second_pass = optimize_lineup(first_pass_series)
-                second_pass_series = pd.Series(second_pass, index=row.index)
-
-                third_pass = optimize_lineup(second_pass_series)
-                third_pass_series = pd.Series(third_pass, index=row.index)
-
-                fourth_pass = optimize_lineup(third_pass_series)
-                fourth_pass_series = pd.Series(fourth_pass, index=row.index)
-
-                fifth_pass = optimize_lineup(fourth_pass_series)
-                fifth_pass_series = pd.Series(fifth_pass, index=row.index)
-                
-                # Second optimization pass
-                final_lineup = optimize_lineup(fifth_pass_series)
-                optimized_lineups.append(final_lineup)
-                
-                if 'Optimize' in swap_var:
-                    progress = (idx + 1) / total_lineups
-                    progress_bar.progress(progress)
-                    status_text.text(f'Optimizing Lineups {idx + 1} of {total_lineups}')
-                else:
-                    pass
-            
-            # Create new dataframe with optimized lineups
-            if 'Optimize' in swap_var:
-                st.session_state['optimized_df_medians'] = pd.DataFrame(optimized_lineups, columns=st.session_state['portfolio'].columns)
-            else:
-                st.session_state['optimized_df_medians'] = st.session_state['portfolio']
-
-            # Create a progress bar
-            progress_bar_winners = st.progress(0)
-            status_text_winners = st.empty()
-            
-            # Process each lineup
-            optimized_lineups_winners = []
-            total_lineups = len(st.session_state['optimized_df_medians'])
-            
-            for idx, row in st.session_state['optimized_df_medians'].iterrows():
-
-                final_lineup = optimize_lineup_winners(row)
-                optimized_lineups_winners.append(final_lineup)
-                
-                if 'Decrease volatility' in swap_var:
-                    progress_winners = (idx + 1) / total_lineups
-                    progress_bar_winners.progress(progress_winners)
-                    status_text_winners.text(f'Lowering Volatility around Winners {idx + 1} of {total_lineups}')
-                else:
-                    pass
-            
-            # Create new dataframe with optimized lineups
-            if 'Decrease volatility' in swap_var:
-                st.session_state['optimized_df_winners'] = pd.DataFrame(optimized_lineups_winners, columns=st.session_state['optimized_df_medians'].columns)
-            else:
-                st.session_state['optimized_df_winners'] = st.session_state['optimized_df_medians']
-
-            # Create a progress bar
-            progress_bar_losers = st.progress(0)
-            status_text_losers = st.empty()
-            
-            # Process each lineup
-            optimized_lineups_losers = []
-            total_lineups = len(st.session_state['optimized_df_winners'])
-            
-            for idx, row in st.session_state['optimized_df_winners'].iterrows():
-
-                final_lineup = optimize_lineup_losers(row)
-                optimized_lineups_losers.append(final_lineup)
-                
-                if 'Increase volatility' in swap_var:
-                    progress_losers = (idx + 1) / total_lineups
-                    progress_bar_losers.progress(progress_losers)
-                    status_text_losers.text(f'Increasing Volatility around Losers {idx + 1} of {total_lineups}')
-                else:
-                    pass
-            
-            # Create new dataframe with optimized lineups
-            if 'Increase volatility' in swap_var:
-                st.session_state['optimized_df'] = pd.DataFrame(optimized_lineups_losers, columns=st.session_state['optimized_df_winners'].columns)
-            else:
-                st.session_state['optimized_df'] = st.session_state['optimized_df_winners']
-            
-            # Calculate new stats for optimized lineups
-            st.session_state['optimized_df']['salary'] = st.session_state['optimized_df'].apply(
-                lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
-            )
-            st.session_state['optimized_df']['median'] = st.session_state['optimized_df'].apply(
-                lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
-            )
-            st.session_state['optimized_df']['Own'] = st.session_state['optimized_df'].apply(
-                lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
-            )
-
-            # Display results
-            st.success('Optimization complete!')
-
-        if 'optimized_df' in st.session_state:
-            st.write("Increase in median highlighted in yellow, descrease in volatility highlighted in blue, increase in volatility highlighted in red:")
-            st.dataframe(
-                st.session_state['optimized_df'].style
-                .apply(highlight_changes, axis=1)
-                .apply(highlight_changes_winners, axis=1)
-                .apply(highlight_changes_losers, axis=1)
-                .background_gradient(axis=0)
-                .background_gradient(cmap='RdYlGn')
-                .format(precision=2),
-                height=1000,
-                use_container_width=True
-            )
-            
-            # Option to download optimized lineups
-            if st.button('Prepare Late Swap Export'):
-                export_df = st.session_state['optimized_df'].copy()
-                
-                # Map player names to their export IDs for all player columns
-                for col in export_df.columns:
-                    if col not in ['salary', 'median', 'Own']:
-                        export_df[col] = export_df[col].map(st.session_state['export_dict'])
-                
-                csv = export_df.to_csv(index=False)
-                st.download_button(
-                    label="Download CSV",
-                    data=csv,
-                    file_name="optimized_lineups.csv",
-                    mime="text/csv"
-                )
-        else:
-            st.write("Current Portfolio")
-            st.dataframe(
-                st.session_state['portfolio'].style
-                .background_gradient(axis=0)
-                .background_gradient(cmap='RdYlGn')
-                .format(precision=2),
-                height=1000,
-                use_container_width=True
-            )
-
-with tab3:
     if st.button('Clear data', key='reset3'):
         st.session_state.clear()
     if 'portfolio' in st.session_state and 'projections_df' in st.session_state:

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):
+    # Create a copy of the projections dataframe to avoid modifying the original
+    projections_df = projections_df.copy()
+    
+    col_count = len(portfolio_df.columns)
+    portfolio_df.columns = range(col_count)
+    
+    if 'player_names' not in projections_df.columns:
+        st.error("No 'player_names' column found in projections file")
+        return projections_df
+    
+    # Get unique player names from portfolio and projections
+    portfolio_players = set()
+    for col in portfolio_df.columns:
+        portfolio_players.update(portfolio_df[col].unique())
+    projection_players = set(projections_df['player_names'].unique())
+    projection_players_list = list(projection_players)
+    
+    # Find players in portfolio that are missing from projections
+    players_missing_from_projections = list(portfolio_players - projection_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]
+            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)
+    
+    # Initialize session state for tracking current player if not exists
+    if 'current_player_index' not in st.session_state:
+        st.session_state.current_player_index = 0
+        st.session_state.players_to_process = players_to_process
+    
+    # Display results
+    if players_missing_from_projections:
+        st.warning("Players in portfolio but missing from projections")
+        
+        # Display remaining players
+        remaining_players = st.session_state.players_to_process[st.session_state.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.current_player_index < len(st.session_state.players_to_process):
+            current_player = st.session_state.players_to_process[st.session_state.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.current_player_index + 1} of {len(st.session_state.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"radio_{current_player}"
+            )
+            
+            if st.button("Confirm Selection"):
+                if selected_option != "None of these":
+                    selected_name = selected_option.split(" (")[0]
+                    projections_df.loc[projections_df['player_names'] == selected_name, 'player_names'] = current_player
+                    st.success(f"Replaced '{selected_name}' with '{current_player}'")
+                    st.session_state['projections_df'] = projections_df
+                
+                # Move to next player
+                st.session_state.current_player_index += 1
+                st.rerun()
+        else:
+            st.success("All players have been processed!")
+            # Reset the index for future runs
+            st.session_state.current_player_index = 0
+            st.session_state.players_to_process = []
+    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