Refactor find_name_mismatches function and update data handling

- Renamed parameters in the find_name_mismatches function for clarity, changing ownership_dict and fpts_dict to ownership_df and fpts_df.
- Updated the logic to use raw copies of dataframes for processing, ensuring the original data remains unaltered.
- Improved the handling of ownership and fpts updates to maintain data integrity during name matching operations.

global_func/find_name_mismatches.py

@@ -4,24 +4,24 @@ import pandas as pd
 import time
 from fuzzywuzzy import process
 
-def find_name_mismatches(contest_df, projections_df, ownership_dict, fpts_dict):
+def find_name_mismatches(contest_df, projections_df, ownership_df, fpts_df):
     # Create a copy of the projections dataframe to avoid modifying the original
-    projections_df = projections_df.copy()
-    contest_df = contest_df.copy()
-    ownership_dict = ownership_dict.copy()
-    fpts_dict = fpts_dict.copy()
+    projections_raw = projections_df.copy()
+    contest_raw = contest_df.copy()
+    ownership_raw = ownership_df.copy()
+    fpts_raw = fpts_df.copy()
     
-    name_columns = [col for col in contest_df.columns if not col in ['BaseName', 'EntryCount']]
+    name_columns = [col for col in contest_raw.columns if not col in ['BaseName', 'EntryCount']]
     
-    if 'player_names' not in projections_df.columns:
+    if 'player_names' not in projections_raw.columns:
         st.error("No 'player_names' column found in projections file")
-        return contest_df, projections_df
+        return contest_raw, projections_raw
     
     # Get unique player names from portfolio and projections
     portfolio_players = set()
     for col in name_columns:
-        portfolio_players.update(contest_df[col].unique())
-    projection_players = set(projections_df['player_names'].unique())
+        portfolio_players.update(contest_raw[col].unique())
+    projection_players = set(projections_raw['player_names'].unique())
     portfolio_players_list = list(portfolio_players)
     projection_players_list = list(projection_players)
     
@@ -79,44 +79,48 @@ def find_name_mismatches(contest_df, projections_df, ownership_dict, fpts_dict):
                 # Process automatic matches
                 for projection_name, contest_name in auto_matches.items():
                     for col in name_columns:
-                        contest_df[col] = contest_df[col].replace(contest_name, projection_name)
+                        contest_raw[col] = contest_raw[col].replace(contest_name, projection_name)
                 
-                if contest_name in ownership_dict:
-                    ownership_dict[projection_name] = ownership_dict.pop(contest_name)
-                if contest_name in fpts_dict:
-                    fpts_dict[projection_name] = fpts_dict.pop(contest_name)
+                if contest_name in ownership_raw:
+                    ownership_raw['Player'] = ownership_raw['Player'].replace(contest_name, projection_name)
+                    ownership_dict = dict(zip(ownership_raw['Player'], ownership_raw['Own']))
+                if contest_name in fpts_raw:
+                    fpts_raw['Player'] = fpts_raw['Player'].replace(contest_name, projection_name)
+                    fpts_dict = dict(zip(fpts_raw['Player'], fpts_raw['FPTS']))
                         
                 # Process manual selections
                 for projection_name, selection in selections.items():
                     if selection != "None of these":
                         selected_name = selection.split(" (")[0]
                         for col in name_columns:
-                            contest_df[col] = contest_df[col].replace(selected_name, projection_name)
+                            contest_raw[col] = contest_raw[col].replace(selected_name, projection_name)
                         
-                        if selected_name in ownership_dict:
-                            ownership_dict[projection_name] = ownership_dict.pop(selected_name)
-                        if selected_name in fpts_dict:
-                            fpts_dict[projection_name] = fpts_dict.pop(selected_name)
+                        if contest_name in ownership_raw:
+                            ownership_raw['Player'] = ownership_raw['Player'].replace(contest_name, projection_name)
+                            ownership_dict = dict(zip(ownership_raw['Player'], ownership_raw['Own']))
+                        if contest_name in fpts_raw:
+                            fpts_raw['Player'] = fpts_raw['Player'].replace(contest_name, projection_name)
+                            fpts_dict = dict(zip(fpts_raw['Player'], fpts_raw['FPTS']))
 
                         st.success(f"Replaced '{selected_name}' with '{projection_name}'")
                 
                 st.success("All changes applied successfully!")
-                st.write(st.session_state['actual_dict'])
-                st.write(st.session_state['ownership_dict'])
-                return contest_df, projections_df, ownership_dict, fpts_dict
+                return contest_raw, projections_raw, ownership_dict, fpts_dict
             
             # Return the current state if form hasn't been submitted yet
-            return contest_df, projections_df, ownership_dict, fpts_dict
+            return contest_raw, projections_raw, ownership_dict, fpts_dict
     else:
         st.success("All players have been automatically matched!")
         # Apply automatic matches
         for projection_name, contest_name in auto_matches.items():
             for col in name_columns:
-                contest_df[col] = contest_df[col].replace(contest_name, projection_name)
+                contest_raw[col] = contest_raw[col].replace(contest_name, projection_name)
             
-            if contest_name in ownership_dict:
-                ownership_dict[projection_name] = ownership_dict.pop(contest_name)
-            if contest_name in fpts_dict:
-                fpts_dict[projection_name] = fpts_dict.pop(contest_name)
+            if contest_name in ownership_raw:
+                ownership_raw['Player'] = ownership_raw['Player'].replace(contest_name, projection_name)
+                ownership_dict = dict(zip(ownership_raw['Player'], ownership_raw['Own']))
+            if contest_name in fpts_raw:
+                fpts_raw['Player'] = fpts_raw['Player'].replace(contest_name, projection_name)
+                fpts_dict = dict(zip(fpts_raw['Player'], fpts_raw['FPTS']))
 
-        return contest_df, projections_df, ownership_dict, fpts_dict
+        return contest_raw, projections_raw, ownership_dict, fpts_dict

global_func/load_contest_file.py

@@ -49,14 +49,14 @@ def load_contest_file(upload, sport):
             if sport == 'MLB':
                 df = df.rename(columns={1: '1B', 2: '2B', 3: '3B', 4: 'C', 5: 'OF1', 6: 'OF2', 7: 'OF3', 8: 'SP1', 9: 'SP2', 10: 'SS'})
             df['Own'] = df['Own'].str.replace('%', '').astype(float)
-            ownership_dict = dict(zip(df['Player'], df['Own']))
-            fpts_dict = dict(zip(df['Player'], df['FPTS']))
+            ownership_df = df[['Player', 'Own']]
+            fpts_df = df[['Player', 'FPTS']]
             cleaned_df = df.drop(columns=['EntryId', 'EntryName', 'TimeRemaining', 'Points', 'Lineup', 'Player', 'Pos', 'Own', 'FPTS'])
             cleaned_df = cleaned_df[['BaseName', 'EntryCount', 'SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']]
             entry_list = list(set(df['BaseName']))
             entry_list.sort()
             
-            return cleaned_df, ownership_dict, fpts_dict, entry_list
+            return cleaned_df, ownership_df, fpts_df, entry_list
         except Exception as e:
             st.error(f'Error loading file: {str(e)}')
             return None