Add stack exposure calculations and refactor player exposure handling in app.py

- Introduced the create_stack_exposures function to calculate stack exposures, enhancing data analysis capabilities.
- Updated app.py to utilize the new function, improving the organization and clarity of stack exposure data presentation.
- Refactored player exposure handling to incorporate new session state variables for field player and stack frames, ensuring consistent data management across user interactions.

app.py

@@ -11,6 +11,7 @@ from global_func.load_contest_file import load_contest_file
 from global_func.load_file import load_file
 from global_func.find_name_mismatches import find_name_mismatches
 from global_func.create_player_exposures import create_player_exposures
+from global_func.create_stack_exposures import create_stack_exposures
 
 player_exposure_format = {'Exposure Overall': '{:.2%}', 'Exposure Top 1%': '{:.2%}', 'Exposure Top 5%': '{:.2%}', 'Exposure Top 10%': '{:.2%}', 'Exposure Top 20%': '{:.2%}'}
 if 'calc_toggle' not in st.session_state:
@@ -171,6 +172,8 @@ with tab2:
             working_df['percentile_finish'] = working_df['index'].rank(pct=True)
             working_df['finish'] = working_df['index']
             working_df = working_df.drop(['sorted', 'index'], axis=1)
+            st.session_state['field_player_frame'] = create_player_exposures(working_df, player_columns)
+            st.session_state['field_stack_frame'] = create_stack_exposures(working_df)
 
     with st.expander("Info and filters"):
         if st.button('Clear data', key='reset3'):
@@ -237,81 +240,54 @@ with tab2:
     with st.container():
         tab1, tab2, tab3 = st.tabs(['Player Used Info', 'Stack Used Info', 'Duplication Info'])
         with tab1:
-            st.session_state['field_frame'] = create_player_exposures(working_df, player_columns)
+            player_view_var = st.radio("View Exposures by:", ['Percentage used', 'Relation to the field'], key='player_view_var')
+
             if entry_parse_var == 'All':
                 st.session_state['player_frame'] = create_player_exposures(working_df, player_columns)
-                st.dataframe(st.session_state['player_frame'].
+                if player_view_var == 'Percentage used':
+                    player_frame_display = st.session_state['player_frame']
+                elif player_view_var == 'Relation to the field':
+                    player_frame_display = st.session_state['player_frame'] - st.session_state['field_player_frame']
+                st.dataframe(player_frame_display.
                     sort_values(by='Exposure Overall', ascending=False).
                     style.background_gradient(cmap='RdYlGn').
-                    format(formatter='{:.2%}', subset=st.session_state['player_frame'].select_dtypes(include=['number']).columns),
+                    format(formatter='{:.2%}', subset=player_frame_display.select_dtypes(include=['number']).columns),
                     hide_index=True)
             else:
                 st.session_state['player_frame'] = create_player_exposures(working_df, player_columns, entry_names)
-                st.dataframe(st.session_state['player_frame'].
+                if player_view_var == 'Percentage used':
+                    player_frame_display = st.session_state['player_frame']
+                elif player_view_var == 'Relation to the field':
+                    player_frame_display = st.session_state['player_frame'] - st.session_state['field_player_frame']
+                st.dataframe(player_frame_display.
                     sort_values(by='Exposure Overall', ascending=False).
                     style.background_gradient(cmap='RdYlGn').
-                    format(formatter='{:.2%}', subset=st.session_state['player_frame'].select_dtypes(include=['number']).columns),
+                    format(formatter='{:.2%}', subset=player_frame_display.select_dtypes(include=['number']).columns),
                     hide_index=True)
         with tab2:
+            stack_view_var = st.radio('View Stack Exposures by:', ['Percentage used', 'Relation to the field'], key = 'stack_view_var')
+
             if entry_parse_var == 'All':
-                overall_stacks = pd.Series(list(working_df['stack'])).value_counts()
-                top_1per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.01]['stack'])).value_counts()
-                top_5per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.05]['stack'])).value_counts()
-                top_10per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.10]['stack'])).value_counts()
-                top_20per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.20]['stack'])).value_counts()
-                stacks_contest_len = len(working_df)
-                stacks_len_1per = len(working_df[working_df['percentile_finish'] <= 0.01])
-                stacks_len_5per = len(working_df[working_df['percentile_finish'] <= 0.05])
-                stacks_len_10per = len(working_df[working_df['percentile_finish'] <= 0.10])
-                stacks_len_20per = len(working_df[working_df['percentile_finish'] <= 0.20])
-                each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
-                each_stacks_set = [overall_stacks, top_1per_stacks, top_5per_stacks, top_10per_stacks, top_20per_stacks]
-                each_stacks_len_set = [stacks_contest_len, stacks_len_1per, stacks_len_5per, stacks_len_10per, stacks_len_20per]
-                stack_count_var = 0
-                for each_stack in each_stacks_set:
-                    stack_frame = each_stack.to_frame().reset_index().rename(columns={'index': 'Stack', 'count': 'Count'})
-                    stack_frame['Percent'] = stack_frame['Count'] / each_stacks_len_set[stack_count_var]
-                    stack_frame = stack_frame[['Stack', 'Percent']]
-                    stack_frame = stack_frame.rename(columns={'Percent': f'Exposure {each_set_name[stack_count_var]}'})
-                    if 'stack_frame' not in st.session_state:
-                        st.session_state['stack_frame'] = stack_frame
-                    else:
-                        st.session_state['stack_frame'] = pd.merge(st.session_state['stack_frame'], stack_frame, on='Stack', how='outer')
-                    stack_count_var += 1
-                st.dataframe(st.session_state['stack_frame'].
+                st.session_state['stack_frame'] = create_stack_exposures(working_df)
+                if stack_view_var == 'Percentage used':
+                    stack_frame_display = st.session_state['stack_frame']
+                elif stack_view_var == 'Relation to the field':
+                    stack_frame_display = st.session_state['stack_frame'] - st.session_state['field_stack_frame']
+                st.dataframe(stack_frame_display.
                     sort_values(by='Exposure Overall', ascending=False).
                     style.background_gradient(cmap='RdYlGn').
-                    format(formatter='{:.2%}', subset=st.session_state['stack_frame'].select_dtypes(include=['number']).columns),
+                    format(formatter='{:.2%}', subset=stack_frame_display.select_dtypes(include=['number']).columns),
                     hide_index=True)
             else:
-                overall_stacks = pd.Series(list(working_df[working_df['BaseName'].isin(entry_names)]['stack'])).value_counts()
-                top_1per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.01]['stack'])).value_counts()
-                top_5per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.05]['stack'])).value_counts()
-                top_10per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.10]['stack'])).value_counts()
-                top_20per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.20]['stack'])).value_counts()
-                stacks_contest_len = len(working_df)
-                stacks_len_1per = len(working_df[working_df['percentile_finish'] <= 0.01])
-                stacks_len_5per = len(working_df[working_df['percentile_finish'] <= 0.05])
-                stacks_len_10per = len(working_df[working_df['percentile_finish'] <= 0.10])
-                stacks_len_20per = len(working_df[working_df['percentile_finish'] <= 0.20])
-                each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
-                each_stacks_set = [overall_stacks, top_1per_stacks, top_5per_stacks, top_10per_stacks, top_20per_stacks]
-                each_stacks_len_set = [stacks_contest_len, stacks_len_1per, stacks_len_5per, stacks_len_10per, stacks_len_20per]
-                stack_count_var = 0
-                for each_stack in each_stacks_set:
-                    stack_frame = each_stack.to_frame().reset_index().rename(columns={'index': 'Stack', 'count': 'Count'})
-                    stack_frame['Percent'] = stack_frame['Count'] / each_stacks_len_set[stack_count_var]
-                    stack_frame = stack_frame[['Stack', 'Percent']]
-                    stack_frame = stack_frame.rename(columns={'Percent': f'Exposure {each_set_name[stack_count_var]}'})
-                    if 'stack_frame' not in st.session_state:
-                        st.session_state['stack_frame'] = stack_frame
-                    else:
-                        st.session_state['stack_frame'] = pd.merge(st.session_state['stack_frame'], stack_frame, on='Stack', how='outer')
-                    stack_count_var += 1
-                st.dataframe(st.session_state['stack_frame'].
+                st.session_state['stack_frame'] = create_stack_exposures(working_df, entry_names)
+                if stack_view_var == 'Percentage used':
+                    stack_frame_display = st.session_state['stack_frame']
+                elif stack_view_var == 'Relation to the field':
+                    stack_frame_display = st.session_state['stack_frame'] - st.session_state['field_stack_frame']
+                st.dataframe(stack_frame_display.
                     sort_values(by='Exposure Overall', ascending=False).
                     style.background_gradient(cmap='RdYlGn').
-                    format(formatter='{:.2%}', subset=st.session_state['stack_frame'].select_dtypes(include=['number']).columns),
+                    format(formatter='{:.2%}', subset=stack_frame_display.select_dtypes(include=['number']).columns),
                     hide_index=True)
         with tab3:
             st.write('holding')

global_func/clean_player_name.py

@@ -1,16 +0,0 @@
-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/create_stack_exposures.py

@@ -0,0 +1,33 @@
+import pandas as pd
+
+def create_stack_exposures(df: pd.DataFrame, entrants: list = None):
+    stack_exposures = pd.DataFrame()
+    if entrants is not None:
+        overall_stacks = pd.Series(list(df[df['BaseName'].isin(entrants)]['stack'])).value_counts()
+    else:
+        overall_stacks = pd.Series(list(df['stack'])).value_counts()
+    top_1per_stacks = pd.Series(list(df[df['percentile_finish'] <= 0.01]['stack'])).value_counts()
+    top_5per_stacks = pd.Series(list(df[df['percentile_finish'] <= 0.05]['stack'])).value_counts()
+    top_10per_stacks = pd.Series(list(df[df['percentile_finish'] <= 0.10]['stack'])).value_counts()
+    top_20per_stacks = pd.Series(list(df[df['percentile_finish'] <= 0.20]['stack'])).value_counts()
+    stacks_contest_len = len(df)
+    stacks_len_1per = len(df[df['percentile_finish'] <= 0.01])
+    stacks_len_5per = len(df[df['percentile_finish'] <= 0.05])
+    stacks_len_10per = len(df[df['percentile_finish'] <= 0.10])
+    stacks_len_20per = len(df[df['percentile_finish'] <= 0.20])
+    each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
+    each_stacks_set = [overall_stacks, top_1per_stacks, top_5per_stacks, top_10per_stacks, top_20per_stacks]
+    each_stacks_len_set = [stacks_contest_len, stacks_len_1per, stacks_len_5per, stacks_len_10per, stacks_len_20per]
+    stack_count_var = 0
+    for each_stack in each_stacks_set:
+        stack_frame = each_stack.to_frame().reset_index().rename(columns={'index': 'Stack', 'count': 'Count'})
+        stack_frame['Percent'] = stack_frame['Count'] / each_stacks_len_set[stack_count_var]
+        stack_frame = stack_frame[['Stack', 'Percent']]
+        stack_frame = stack_frame.rename(columns={'Percent': f'Exposure {each_set_name[stack_count_var]}'})
+        if len(stack_exposures) == 0:
+            stack_exposures = stack_frame
+        else:
+            stack_exposures = pd.merge(stack_exposures, stack_frame, on='Stack', how='outer')
+        stack_count_var += 1
+
+        return stack_exposures

global_func/find_csv_mismatches.py

@@ -1,93 +0,0 @@
-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/highlight_rows.py

@@ -1,29 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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_ss_file.py

@@ -1,34 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,188 +0,0 @@
-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