Refine player lineup processing logic in load_contest_file function

- Enhanced the handling of player names and position indicators by implementing a more robust splitting mechanism, ensuring accurate player assignments.
- Improved debug output to display processed players with their respective positions, aiding in traceability during execution.
- These changes contribute to ongoing efforts to enhance data handling and improve user experience within the application.

global_func/load_contest_file.py

@@ -87,51 +87,70 @@ def load_contest_file(upload, sport):
                 print(f"\nProcessing lineup {idx}:")
                 print(f"Original lineup string: {row['Lineup']}")
                 
-                # Get all players in the lineup and clean up the strings
-                players = row['Lineup'].split(',')
-                print(f"After initial split: {players}")
+                # First split by position indicators to preserve player names
+                lineup_parts = []
+                current_part = row['Lineup']
+                for pos in pos_values:
+                    if pos in current_part:
+                        parts = current_part.split(pos)
+                        if len(parts) > 1:
+                            lineup_parts.append(pos)  # Add the position
+                            current_part = parts[1]  # Keep the rest for further processing
                 
-                cleaned_players = []
+                # Now split the remaining parts by commas, but only if they're not part of a player name
+                players = []
                 current_position = None
-                
-                for item in players:
-                    item = item.strip()
-                    print(f"\nProcessing item: {item}")
-                    
-                    # If the item is just a position indicator, store it
-                    if item in pos_values:
-                        current_position = item
-                        print(f"Found position: {current_position}")
+                for part in lineup_parts:
+                    part = part.strip()
+                    if part in pos_values:
+                        current_position = part
                         continue
                     
-                    # If we have a position and a player name
-                    if current_position:
-                        # Remove any trailing position indicators
-                        for pos in pos_values:
-                            if item.endswith(pos):
-                                item = item[:-len(pos)].strip()
-                        print(f"Adding player with position {current_position}: {item}")
-                        cleaned_players.append(item)
-                        current_position = None
+                    # Split by comma only if it's followed by a position indicator
+                    if ',' in part:
+                        subparts = part.split(',')
+                        for subpart in subparts:
+                            subpart = subpart.strip()
+                            # Check if this subpart ends with a position
+                            has_position = any(subpart.endswith(pos) for pos in pos_values)
+                            if has_position:
+                                # This is a complete player entry
+                                for pos in pos_values:
+                                    if subpart.endswith(pos):
+                                        player = subpart[:-len(pos)].strip()
+                                        players.append((current_position, player))
+                                        current_position = pos
+                                        break
+                            else:
+                                # This might be part of a player name (like J.P., Crawford)
+                                # Combine with the next part
+                                if players:
+                                    last_pos, last_player = players[-1]
+                                    players[-1] = (last_pos, last_player + ',' + subpart)
+                                else:
+                                    players.append((current_position, subpart))
                     else:
-                        # If we somehow got a player without a position, try to clean it
+                        # No comma, just clean and add
                         for pos in pos_values:
-                            if item.endswith(pos):
-                                item = item[:-len(pos)].strip()
+                            if part.endswith(pos):
+                                player = part[:-len(pos)].strip()
+                                players.append((current_position, player))
+                                current_position = pos
                                 break
-                        print(f"Adding player without position: {item}")
-                        cleaned_players.append(item)
                 
-                print(f"\nFinal cleaned players: {cleaned_players}")
+                print(f"Processed players with positions: {players}")
+                
+                # Now fill the positions using the processed players
+                cleaned_players = [player for _, player in players]
                 
                 # First pass: fill required positions (excluding OF)
                 required_positions = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS']
                 for pos in required_positions:
-                    for player in cleaned_players:
+                    for position, player in players:
                         if is_eligible_for_position(player, pos):
                             print(f"Assigning {player} to {pos}")
                             df.at[idx, pos] = player
-                            cleaned_players.remove(player)
+                            players.remove((position, player))
                             break
                     else:
                         print(f"No player found for {pos}")
@@ -139,11 +158,11 @@ def load_contest_file(upload, sport):
                 # Second pass: fill OF positions with remaining players
                 of_positions = ['OF1', 'OF2', 'OF3']
                 for pos in of_positions:
-                    for player in cleaned_players:
+                    for position, player in players:
                         if 'OF' in pos_dict.get(player, '').split('/'):
                             print(f"Assigning {player} to {pos}")
                             df.at[idx, pos] = player
-                            cleaned_players.remove(player)
+                            players.remove((position, player))
                             break
                     else:
                         print(f"No player found for {pos}, using -1")