removing some unused code

app.py

@@ -1482,518 +1482,6 @@ if selected_tab == 'Data Load':
             
             del st.session_state['portfolio'], st.session_state['export_portfolio']
 
-# 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
-#             )
-
 if selected_tab == 'Manage Portfolio':
     if 'origin_portfolio' in st.session_state and 'projections_df' in st.session_state:
         with st.container():