Refactor file upload functionality in `app.py` and `load_file.py`

- Replaced portfolio file upload with contest file upload in `app.py`, streamlining the interface for users.
- Updated `load_file.py` to process contest files, extracting relevant player data and ownership information.
- Enhanced data handling by renaming columns and ensuring proper formatting for player positions and ownership percentages.

app.py

@@ -16,10 +16,6 @@ from global_func.highlight_rows import highlight_changes, highlight_changes_winn
 from global_func.load_csv import load_csv
 from global_func.find_csv_mismatches import find_csv_mismatches
 
-freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
-player_wrong_names_mlb = ['Enrique Hernandez']
-player_right_names_mlb = ['Kike Hernandez']
-
 tab1, tab2 = st.tabs(["Data Load", "Contest Analysis"])
 with tab1:
     if st.button('Clear data', key='reset1'):
@@ -58,51 +54,19 @@ with tab1:
             st.dataframe(st.session_state['csv_file'].head(10))
     
     with col2:
-        st.subheader("Portfolio File")
-        st.info("Go ahead and upload a portfolio file here. Only include player columns and an optional 'Stack' column if you are playing MLB.")
-        saber_toggle = st.radio("Are you uploading from SaberSim?", options=['No', 'Yes'])
-        st.info("If you are uploading from SaberSim, you will need to upload a CSV file for the slate for name matching.")
-        if saber_toggle == 'Yes':
-            if csv_file is not None:
-                portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
-                if 'portfolio' in st.session_state:
-                    del st.session_state['portfolio']
-                if 'export_portfolio' in st.session_state:
-                    del st.session_state['export_portfolio']
-
-        else:
-            portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
-            if 'portfolio' in st.session_state:
-                del st.session_state['portfolio']
-            if 'export_portfolio' in st.session_state:
-                del st.session_state['export_portfolio']
-
-        if portfolio_file:
-            if saber_toggle == 'Yes':
-                st.session_state['export_portfolio'], st.session_state['portfolio'] = load_ss_file(portfolio_file, st.session_state['csv_file'])
-                st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all')
-                st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True)
-                st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all')
-                st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True)
-            else:
-                st.session_state['export_portfolio'], st.session_state['portfolio'] = load_file(portfolio_file)
-                st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all')
-                st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True)
-                st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all')
-                st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True)
-            # Check if Stack column exists in the portfolio
-            if 'Stack' in st.session_state['portfolio'].columns:
-                # Create dictionary mapping index to Stack values
-                stack_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack']))
-                st.write(f"Found {len(stack_dict)} stack assignments")
-                st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['Stack'])
-            else:
-                stack_dict = None
-                st.info("No Stack column found in portfolio")
-            if st.session_state['portfolio'] is not None:
-                st.success('Portfolio file loaded successfully!')
-                st.session_state['portfolio'] = st.session_state['portfolio'].apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
-                st.dataframe(st.session_state['portfolio'].head(10))
+        st.subheader("Contest File")
+        st.info("Go ahead and upload a Contest file here. Only include player columns and an optional 'Stack' column if you are playing MLB.")
+        Contest_file = st.file_uploader("Upload Contest File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
+        if 'Contest' in st.session_state:
+            del st.session_state['Contest']
+
+        if Contest_file:
+            st.session_state['Contest'], st.session_state['position_dict'], st.session_state['ownership_dict'] = load_file(Contest_file)
+            st.session_state['Contest'] = st.session_state['Contest'].dropna(how='all')
+            st.session_state['Contest'] = st.session_state['Contest'].reset_index(drop=True)
+            if st.session_state['Contest'] is not None:
+                st.success('Contest file loaded successfully!')
+                st.dataframe(st.session_state['Contest'].head(10))
 
     with col3:
         st.subheader("Projections File")
@@ -131,361 +95,42 @@ with tab1:
             export_projections, projections = load_file(projections_file)
             if projections is not None:
                 st.success('Projections file loaded successfully!')
-                projections = projections.apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
                 st.dataframe(projections.head(10))
 
-    if portfolio_file and projections_file:
-        if st.session_state['portfolio'] is not None and projections is not None:
-            st.subheader("Name Matching Analysis")
-            # Initialize projections_df in session state if it doesn't exist
-            if 'projections_df' not in st.session_state:
-                st.session_state['projections_df'] = projections.copy()
-                st.session_state['projections_df']['salary'] = (st.session_state['projections_df']['salary'].astype(str).str.replace(',', '').astype(float).astype(int))
+    # if Contest_file and projections_file:
+    #     if st.session_state['Contest'] is not None and projections is not None:
+    #         st.subheader("Name Matching Analysis")
+    #         # Initialize projections_df in session state if it doesn't exist
+    #         if 'projections_df' not in st.session_state:
+    #             st.session_state['projections_df'] = projections.copy()
+    #             st.session_state['projections_df']['salary'] = (st.session_state['projections_df']['salary'].astype(str).str.replace(',', '').astype(float).astype(int))
             
-            # Update projections_df with any new matches
-            st.session_state['projections_df'] = find_name_mismatches(st.session_state['portfolio'], st.session_state['projections_df'])
-            if csv_file is not None and 'export_dict' not in st.session_state:
-                    # Create a dictionary of Name to Name+ID from csv_file
-                    try:
-                        name_id_map = dict(zip(
-                            st.session_state['csv_file']['Name'], 
-                            st.session_state['csv_file']['Name + ID']
-                        ))
-                    except:
-                        name_id_map = dict(zip(
-                            st.session_state['csv_file']['Nickname'], 
-                            st.session_state['csv_file']['Id']
-                        ))
+    #         # Update projections_df with any new matches
+    #         st.session_state['projections_df'] = find_name_mismatches(st.session_state['Contest'], st.session_state['projections_df'])
+    #         if csv_file is not None and 'export_dict' not in st.session_state:
+    #                 # Create a dictionary of Name to Name+ID from csv_file
+    #                 try:
+    #                     name_id_map = dict(zip(
+    #                         st.session_state['csv_file']['Name'], 
+    #                         st.session_state['csv_file']['Name + ID']
+    #                     ))
+    #                 except:
+    #                     name_id_map = dict(zip(
+    #                         st.session_state['csv_file']['Nickname'], 
+    #                         st.session_state['csv_file']['Id']
+    #                     ))
                     
-                    # Function to find best match
-                    def find_best_match(name):
-                        best_match = process.extractOne(name, name_id_map.keys())
-                        if best_match and best_match[1] >= 85:  # 85% match threshold
-                            return name_id_map[best_match[0]]
-                        return name  # Return original name if no good match found
+    #                 # Function to find best match
+    #                 def find_best_match(name):
+    #                     best_match = process.extractOne(name, name_id_map.keys())
+    #                     if best_match and best_match[1] >= 85:  # 85% match threshold
+    #                         return name_id_map[best_match[0]]
+    #                     return name  # Return original name if no good match found
                     
-                    # Apply the matching
-                    projections['upload_match'] = projections['player_names'].apply(find_best_match)
-                    st.session_state['export_dict'] = dict(zip(projections['player_names'], projections['upload_match']))
+    #                 # Apply the matching
+    #                 projections['upload_match'] = projections['player_names'].apply(find_best_match)
+    #                 st.session_state['export_dict'] = dict(zip(projections['player_names'], projections['upload_match']))
 
 with tab2:
     if st.button('Clear data', key='reset3'):
         st.session_state.clear()
-    if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
-        col1, col2, col3 = st.columns([1, 8, 1])
-        excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Win%', 'Lineup Edge']
-        with col1:
-            site_var = st.selectbox("Select Site", ['Draftkings', 'Fanduel'])
-            sport_var = st.selectbox("Select Sport", ['NFL', 'MLB', 'NBA', 'NHL', 'MMA'])
-            st.info("It currently does not matter what sport you select, it may matter in the future.")
-            type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown'])
-            Contest_Size = st.number_input("Enter Contest Size", value=25000, min_value=1, step=1)
-            strength_var = st.selectbox("Select field strength", ['Average', 'Sharp', 'Weak'])
-        if site_var == 'Draftkings':
-            if type_var == 'Classic':
-                map_dict = {
-                    'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                    'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                    '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'])),
-                    'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                    'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                    'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                    'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-                }
-            elif type_var == 'Showdown':
-                if sport_var == 'NFL':
-                    map_dict = {
-                        'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                        'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                        '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'])),
-                        'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                        'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
-                        'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                        'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-                    }
-                elif sport_var != 'NFL':
-                    map_dict = {
-                        'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                        'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                        'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] / 1.5)),
-                        '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'])),
-                        'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                        'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                        'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                        'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-                    }
-        elif site_var == 'Fanduel':
-            map_dict = {
-                'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                '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'])),
-                'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
-                'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
-            }
-        
-        if type_var == 'Classic':
-            st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), 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), 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), axis=1)
-            if stack_dict is not None:
-                st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].index.map(stack_dict)
-        elif type_var == 'Showdown':
-            # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
-            st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
-                lambda row: map_dict['cpt_salary_map'].get(row.iloc[0], 0) + 
-                          sum(map_dict['salary_map'].get(player, 0) for player in row.iloc[1:]),
-                axis=1
-            )
-            
-            # Calculate median (CPT uses cpt_proj_map, others use proj_map)
-            st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
-                lambda row: map_dict['cpt_proj_map'].get(row.iloc[0], 0) + 
-                          sum(map_dict['proj_map'].get(player, 0) for player in row.iloc[1:]),
-                axis=1
-            )
-            
-            # Calculate ownership (CPT uses cpt_own_map, others use own_map)
-            st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
-                lambda row: map_dict['cpt_own_map'].get(row.iloc[0], 0) + 
-                          sum(map_dict['own_map'].get(player, 0) for player in row.iloc[1:]),
-                axis=1
-            )
-        with col3:
-            with st.form(key='filter_form'):
-                max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, step=1)
-                min_salary = st.number_input("Min acceptable salary?", value=1000, min_value=1000, step=100)
-                max_salary = st.number_input("Max acceptable salary?", value=60000, min_value=1000, step=100)
-                max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=.50, min_value=0.005, step=.001)
-                player_names = set()
-                for col in st.session_state['portfolio'].columns:
-                    if col not in excluded_cols:
-                        player_names.update(st.session_state['portfolio'][col].unique())
-                player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[])
-                player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[])
-                if stack_dict is not None:
-                    stack_toggle = st.selectbox("Include specific stacks?", options=['All Stacks', 'Specific Stacks'], index=0)
-                    stack_selections = st.multiselect("If Specific Stacks, Which to include?", options=sorted(list(set(stack_dict.values()))), default=[])
-                    stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[])
-                
-                submitted = st.form_submit_button("Submit")
-
-        with col2:
-            st.session_state['portfolio'] = predict_dupes(st.session_state['portfolio'], map_dict, site_var, type_var, Contest_Size, strength_var)
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Dupes'] <= max_dupes]
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] >= min_salary]
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] <= max_salary]
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Finish_percentile'] <= max_finish_percentile]
-            if stack_dict is not None:
-                if stack_toggle == 'All Stacks':
-                    st.session_state['portfolio'] = st.session_state['portfolio']
-                    st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-                else:
-                    st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Stack'].isin(stack_selections)]
-                    st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-            if player_remove:
-                # Create mask for lineups that contain any of the removed players
-                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                remove_mask = st.session_state['portfolio'][player_columns].apply(
-                    lambda row: not any(player in list(row) for player in player_remove), axis=1
-                )
-                st.session_state['portfolio'] = st.session_state['portfolio'][remove_mask]
-            
-            if player_lock:
-                # Create mask for lineups that contain all locked players
-                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                
-                lock_mask = st.session_state['portfolio'][player_columns].apply(
-                    lambda row: all(player in list(row) for player in player_lock), axis=1
-                )
-                st.session_state['portfolio'] = st.session_state['portfolio'][lock_mask]
-            export_file = st.session_state['portfolio'].copy()
-            st.session_state['portfolio'] = st.session_state['portfolio'].sort_values(by='median', ascending=False)
-            if csv_file is not None:
-                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                for col in player_columns:
-                    export_file[col] = export_file[col].map(st.session_state['export_dict'])
-            with st.expander("Download options"):
-                if stack_dict is not None:
-                    with st.form(key='stack_form'):
-                        st.subheader("Stack Count Adjustments")
-                        st.info("This allows you to fine tune the stacks that you wish to export. If you want to make sure you don't export any of a specific stack you can 0 it out.")
-                        # Create a container for stack value inputs
-                        sort_container = st.container()
-                        with sort_container:
-                            sort_var = st.selectbox("Sort export portfolio by:", options=['median', 'Lineup Edge', 'Own'])
-                        
-                        # Get unique stack values
-                        unique_stacks = sorted(list(set(stack_dict.values())))
-                        
-                        # Create a dictionary to store stack multipliers
-                        if 'stack_multipliers' not in st.session_state:
-                            st.session_state.stack_multipliers = {stack: 0.0 for stack in unique_stacks}
-                        
-                        # Create columns for the stack inputs
-                        num_cols = 6  # Number of columns to display
-                        for i in range(0, len(unique_stacks), num_cols):
-                            cols = st.columns(num_cols)
-                            for j, stack in enumerate(unique_stacks[i:i+num_cols]):
-                                with cols[j]:
-                                    # Create a unique key for each number input
-                                    key = f"stack_count_{stack}"
-                                    # Get the current count of this stack in the portfolio
-                                    current_stack_count = len(st.session_state['portfolio'][st.session_state['portfolio']['Stack'] == stack])
-                                    # Create number input with current value and max value based on actual count
-                                    st.session_state.stack_multipliers[stack] = st.number_input(
-                                        f"{stack} count",
-                                        min_value=0.0,
-                                        max_value=float(current_stack_count),
-                                        value=float(current_stack_count),
-                                        step=1.0,
-                                        key=key
-                                    )
-                        
-                        # Create a copy of the portfolio
-                        portfolio_copy = st.session_state['portfolio'].copy()
-                        
-                        # Create a list to store selected rows
-                        selected_rows = []
-                        
-                        # For each stack, select the top N rows based on the count value
-                        for stack in unique_stacks:
-                            if stack in st.session_state.stack_multipliers:
-                                count = int(st.session_state.stack_multipliers[stack])
-                                # Get rows for this stack
-                                stack_rows = portfolio_copy[portfolio_copy['Stack'] == stack]
-                                # Sort by median and take top N rows
-                                top_rows = stack_rows.nlargest(count, sort_var)
-                                selected_rows.append(top_rows)
-                        
-                        # Combine all selected rows
-                        portfolio_copy = pd.concat(selected_rows)
-                        
-                        # Update export_file with filtered data
-                        export_file = portfolio_copy.copy()
-                        
-                        submitted = st.form_submit_button("Submit")
-                        if submitted:
-                            st.write('Export portfolio updated!')
-                
-            st.download_button(label="Download Portfolio", data=export_file.to_csv(index=False), file_name="portfolio.csv", mime="text/csv")
-            # Display the paginated dataframe first
-            st.dataframe(
-                st.session_state['portfolio'].style
-                .background_gradient(axis=0)
-                .background_gradient(cmap='RdYlGn')
-                .background_gradient(cmap='RdYlGn_r', subset=['Finish_percentile', 'Own', 'Dupes'])
-                .format(freq_format, precision=2), 
-                height=1000,
-                use_container_width=True
-            )
-
-            # Add pagination controls below the dataframe
-            total_rows = len(st.session_state['portfolio'])
-            rows_per_page = 500
-            total_pages = (total_rows + rows_per_page - 1) // rows_per_page  # Ceiling division
-
-            # Initialize page number in session state if not exists
-            if 'current_page' not in st.session_state:
-                st.session_state.current_page = 1
-
-            # Display current page range info and pagination control in a single line
-            st.write(
-                f"Showing rows {(st.session_state.current_page - 1) * rows_per_page + 1} "
-                f"to {min(st.session_state.current_page * rows_per_page, total_rows)} of {total_rows}"
-            )
-            
-            # Add page number input
-            st.session_state.current_page = st.number_input(
-                f"Page (1-{total_pages})", 
-                min_value=1, 
-                max_value=total_pages,
-                value=st.session_state.current_page
-            )
-
-            # Calculate start and end indices for current page
-            start_idx = (st.session_state.current_page - 1) * rows_per_page
-            end_idx = min(start_idx + rows_per_page, total_rows)
-
-            # Get the subset of data for the current page
-            current_page_data = st.session_state['portfolio'].iloc[start_idx:end_idx]
-            
-            # Create player summary dataframe
-            player_stats = []
-            player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-            
-            if type_var == 'Showdown':
-                # Handle Captain positions
-                for player in player_names:
-                    # Create mask for lineups where this player is Captain (first column)
-                    cpt_mask = st.session_state['portfolio'][player_columns[0]] == player
-                    
-                    if cpt_mask.any():
-                        player_stats.append({
-                            'Player': f"{player} (CPT)",
-                            'Lineup Count': cpt_mask.sum(),
-                            'Avg Median': st.session_state['portfolio'][cpt_mask]['median'].mean(),
-                            'Avg Own': st.session_state['portfolio'][cpt_mask]['Own'].mean(),
-                            'Avg Dupes': st.session_state['portfolio'][cpt_mask]['Dupes'].mean(),
-                            'Avg Finish %': st.session_state['portfolio'][cpt_mask]['Finish_percentile'].mean(),
-                            'Avg Lineup Edge': st.session_state['portfolio'][cpt_mask]['Lineup Edge'].mean(),
-                        })
-                    
-                    # Create mask for lineups where this player is FLEX (other columns)
-                    flex_mask = st.session_state['portfolio'][player_columns[1:]].apply(
-                        lambda row: player in list(row), axis=1
-                    )
-                    
-                    if flex_mask.any():
-                        player_stats.append({
-                            'Player': f"{player} (FLEX)",
-                            'Lineup Count': flex_mask.sum(),
-                            'Avg Median': st.session_state['portfolio'][flex_mask]['median'].mean(),
-                            'Avg Own': st.session_state['portfolio'][flex_mask]['Own'].mean(),
-                            'Avg Dupes': st.session_state['portfolio'][flex_mask]['Dupes'].mean(),
-                            'Avg Finish %': st.session_state['portfolio'][flex_mask]['Finish_percentile'].mean(),
-                            'Avg Lineup Edge': st.session_state['portfolio'][flex_mask]['Lineup Edge'].mean(),
-                        })
-            else:
-                # Original Classic format processing
-                for player in player_names:
-                    player_mask = st.session_state['portfolio'][player_columns].apply(
-                        lambda row: player in list(row), axis=1
-                    )
-                    
-                    if player_mask.any():
-                        player_stats.append({
-                            'Player': player,
-                            'Lineup Count': player_mask.sum(),
-                            'Avg Median': st.session_state['portfolio'][player_mask]['median'].mean(),
-                            'Avg Own': st.session_state['portfolio'][player_mask]['Own'].mean(),
-                            'Avg Dupes': st.session_state['portfolio'][player_mask]['Dupes'].mean(),
-                            'Avg Finish %': st.session_state['portfolio'][player_mask]['Finish_percentile'].mean(),
-                            'Avg Lineup Edge': st.session_state['portfolio'][player_mask]['Lineup Edge'].mean(),
-                        })
-            
-            player_summary = pd.DataFrame(player_stats)
-            player_summary = player_summary.sort_values('Lineup Count', ascending=False)
-            
-            st.subheader("Player Summary")
-            st.dataframe(
-                player_summary.style
-                .background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes'])
-                .format({
-                    'Avg Median': '{:.2f}',
-                    'Avg Own': '{:.2f}',
-                    'Avg Dupes': '{:.2f}',
-                    'Avg Finish %': '{:.2%}',
-                    'Avg Lineup Edge': '{:.2%}'
-                }),
-                height=400,
-                use_container_width=True
-            )

global_func/load_file.py

@@ -8,23 +8,25 @@ from fuzzywuzzy import process
 from global_func.clean_player_name import clean_player_name
 
 def load_file(upload):
+    pos_values = ['P', 'C', '1B', '2B', '3B', 'SS', 'OF']
     if upload is not None:
         try:
             if upload.name.endswith('.csv'):
-                df = pd.read_csv(upload)
+                raw_df = pd.read_csv(upload)
             elif upload.name.endswith(('.xls', '.xlsx')):
-                df = pd.read_excel(upload)
+                raw_df = pd.read_excel(upload)
             else:
                 st.error('Please upload either a CSV or Excel file')
                 return None
             
-            export_df = df.copy()
+            df = raw_df[['EntryId', 'EntryName', 'TimeRemaining', 'Points', 'Lineup', 'Player', 'Roster Position', '%Drafted', 'FPTS']]
+            df = df.rename(columns={'Roster Position': 'Pos', '%Drafted': 'Own'})
+            df['Lineup'] = df['Lineup'].replace(pos_values, ',')
+            df['Lineup'] = df['Lineup'].str.split(',')
+            position_dict = dict(zip(df['Player'], df['Pos']))
+            ownership_dict = dict(zip(df['Player'], df['Own']))
             
-            for col in df.columns:
-                if df[col].dtype == 'object':
-                    df[col] = df[col].apply(lambda x: clean_player_name(x) if isinstance(x, str) else x)
-            
-            return export_df, df
+            return df, position_dict, ownership_dict
         except Exception as e:
             st.error(f'Error loading file: {str(e)}')
             return None