Refactor tab structure in app.py: remove the 'Late Swap' tab and adjust related logic to streamline user interface and improve overall functionality in portfolio management.

app.py

@@ -21,7 +21,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", "Manage Portfolio"])
 with tab1:
     if st.button('Clear data', key='reset1'):
         st.session_state.clear()
@@ -171,519 +171,519 @@ with tab1:
             
             st.session_state['origin_portfolio'] = st.session_state['portfolio'].copy()
 
-with tab2:
-    if st.button('Clear data', key='reset2'):
-        st.session_state.clear()
+# 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:
+#     if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
 
-        optimized_df = None
+#         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
-        )
+#         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
-        )
+#         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']
+#         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
-            )
+#             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)
+#         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
-                    })
+#             # 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()
+#             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)
+#                 # 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)
+#                 # 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
+#                 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 = []
+#                     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)
+#                     # 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()
+#                     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'])
+#                         # 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']
-                        }
+#                         # 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]
+#                 # 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()
+#             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
+#                 # 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)
+#                 # 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)
+#                 # 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
+#                     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
+#                         # 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 = []
+#                         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)
+#                         # 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()
+#                         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'])
+#                             # 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
+#                             # 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]
+#                 # 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()
+#             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
+#                 # 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)
+#                 # 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)
+#                 # 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
+#                     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
+#                         # 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 = []
+#                         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)
+#                         # 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()
+#                         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'])
+#                             # 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
+#                             # 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]
+#                 # 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()
+#             # 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'])
+#             # 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)
+#             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)
+#                 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)
+#                 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)
+#                 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)
+#                 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)
+#                 # 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
+#                 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 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()
+#             # 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'])
+#             # 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():
+#             for idx, row in st.session_state['optimized_df_medians'].iterrows():
 
-                final_lineup = optimize_lineup_winners(row)
-                optimized_lineups_winners.append(final_lineup)
+#                 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
+#                 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 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()
+#             # 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'])
+#             # 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():
+#             for idx, row in st.session_state['optimized_df_winners'].iterrows():
 
-                final_lineup = optimize_lineup_losers(row)
-                optimized_lineups_losers.append(final_lineup)
+#                 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
+#                 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']
+#             # 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
-            )
+#             # 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!')
+#             # 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
-            )
+#         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()
+#             # 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'])
+#                 # 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
-            )
+#                 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:
+with tab2:
     if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
         
         excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Win%', 'Lineup Edge']