Enhance player matching interface in `find_name_mismatches.py` and update `app.py` for improved data display

- Updated the matching logic to allow for automatic matches with a confidence level of 90% or higher, improving accuracy in identifying players.
- Introduced a form for batch processing of player matches, enhancing user experience during manual selections.
- Added dataframes in `app.py` to display the top 100 entries of `contest_df` and `projections_df`, improving visibility of the data being processed.

app.py

@@ -78,6 +78,8 @@ with tab1:
             
             # Update projections_df with any new matches
             st.session_state['contest_df'], st.session_state['projections_df'] = find_name_mismatches(st.session_state['Contest'], st.session_state['projections_df'])
+    st.dataframe(st.session_state['contest_df'].head(100))
+    st.dataframe(st.session_state['projections_df'].head(100))
 
 with tab2:
     if st.button('Clear data', key='reset3'):

global_func/find_name_mismatches.py

@@ -24,74 +24,75 @@ def find_name_mismatches(contest_df, projections_df):
     projection_players_list = list(projection_players)
     
     # Find players in portfolio that are missing from projections
-    players_missing_from_projections = list(projection_players -portfolio_players)
+    players_missing_from_projections = list(projection_players - portfolio_players)
     
-    # Automatically handle 100% matches before starting interactive process
+    # Automatically handle 90%+ matches before starting interactive process
+    auto_matches = {}
     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, portfolio_players_list, limit=1)
-        if closest_matches[0][1] == 100:  # If perfect match found
+        if closest_matches[0][1] >= 90:  # If high confidence match found
             match_name = closest_matches[0][0]
-            # Update all occurrences in contest_df
-            for col in name_columns:
-                contest_df[col] = contest_df[col].replace(player, match_name)
-            st.success(f"Automatically matched '{player}' with '{match_name}' (100% match)")
+            auto_matches[player] = match_name
+            st.success(f"Automatically matched '{player}' with '{match_name}' ({closest_matches[0][1]}% match)")
         else:
             players_to_process.append(player)
     
-    # Initialize session state for tracking current player if not exists
-    if 'current_player_index' not in st.session_state:
-        st.session_state.current_player_index = 0
-        st.session_state.players_to_process = players_to_process
-    
-    # Display results
-    if players_missing_from_projections:
-        st.warning("Players in portfolio but missing from projections")
+    if players_to_process:
+        st.warning(f"Found {len(players_to_process)} players that need manual matching")
         
-        # Display remaining players
-        remaining_players = st.session_state.players_to_process[st.session_state.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.current_player_index < len(st.session_state.players_to_process):
-            current_player = st.session_state.players_to_process[st.session_state.current_player_index]
-            
-            # Find the top 3 closest matches
-            closest_matches = process.extract(current_player, portfolio_players_list, limit=3)
+        # Create a form for batch processing
+        with st.form("name_matching_form"):
+            # Create tabs for each player
+            tabs = st.tabs([f"Player {i+1}" for i in range(len(players_to_process))])
             
-            st.write(f"**Missing Player {st.session_state.current_player_index + 1} of {len(st.session_state.players_to_process)}:** {current_player}")
+            # Dictionary to store selections
+            selections = {}
             
-            # Create radio buttons for selection
-            options = [f"{match[0]} ({match[1]}%)" for match in closest_matches]
-            options.append("None of these")
+            # Populate each tab
+            for i, player in enumerate(players_to_process):
+                with tabs[i]:
+                    st.write(f"**Projection Name:** {player}")
+                    
+                    # Find the top 3 closest matches
+                    closest_matches = process.extract(player, portfolio_players_list, limit=3)
+                    
+                    # Create radio buttons for selection
+                    options = [f"{match[0]} ({match[1]}%)" for match in closest_matches]
+                    options.append("None of these")
+                    
+                    selections[player] = st.radio(
+                        f"Select correct match:",
+                        options,
+                        key=f"radio_{player}"
+                    )
             
-            selected_option = st.radio(
-                f"Select correct match:",
-                options,
-                key=f"radio_{current_player}"
-            )
+            # Submit button for the entire form
+            submitted = st.form_submit_button("Apply All Changes")
             
-            if st.button("Confirm Selection"):
-                if selected_option != "None of these":
-                    selected_name = selected_option.split(" (")[0]
-                    # Update all occurrences in contest_df
+            if submitted:
+                # Process automatic matches
+                for projection_name, contest_name in auto_matches.items():
                     for col in name_columns:
-                        contest_df[col] = contest_df[col].replace(current_player, selected_name)
-                    st.success(f"Replaced '{current_player}' with '{selected_name}'")
-                    st.session_state['contest_df'] = contest_df
+                        contest_df[col] = contest_df[col].replace(contest_name, projection_name)
                 
-                # Move to next player
-                st.session_state.current_player_index += 1
-                st.rerun()
-        else:
-            st.success("All players have been processed!")
-            # Reset the index for future runs
-            st.session_state.current_player_index = 0
-            st.session_state.players_to_process = []
+                # 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)
+                        st.success(f"Replaced '{selected_name}' with '{projection_name}'")
+                
+                st.success("All changes applied successfully!")
+                return contest_df, projections_df
     else:
-        st.success("All portfolio players found in projections!")
-    
-    return contest_df, projections_df
+        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)
+        return contest_df, projections_df