Updated handling of Explanation when cards are renamed

After a set of cards is generated, the previous logic included a check for card names that have already been used by pre-existing MTG cards. If this situation was detected, the card's name is re-generated (keeping all other card information unchanged). The card name is re-generated until a name is generated that has not been used already.

Unfortunately, the previous logic did not also update the Explanation with the newly regenerated card name(s). This commit implements code that also updates the Explanation with the newly regenerated card name(s).

app.py

@@ -377,62 +377,115 @@ def CreateCard(msg: str, card_model: str, extract_model: str, temp: float):
             parsed_list: MTGCardList = completion.choices[0].message.parsed
             cards = parsed_list.cards
             set_name = parsed_list.Name
-            # Clean the explanation to remove quotes around card names
-            explanation = clean_explanation_quotes(parsed_list, card_model)
+            # Get original explanation before any renaming
+            original_explanation = parsed_list.explanation
             
             # Track names in the current batch to ensure uniqueness within the batch
             batch_names = set()
+            # Track name mappings for updating explanation (old_name -> new_name)
+            name_mappings = {}
             
             # Check if any generated card names are duplicates and regenerate them
             for i, card in enumerate(cards):
+                original_name = card.Name
                 # Check if name is duplicate in existing card database
                 if card.Name in card_names:
-                    try:
-                        # Combine existing names and current batch names to avoid duplicates
-                        all_used_names = card_names | batch_names
-                        new_name = generate_unique_name_for_card(
-                            parsed_card=card,
-                            used_names=all_used_names,
-                            extract_model=extract_model,
-                        )
-                        # Verify the regenerated name is actually unique
-                        if new_name in card_names:
-                            print(f"⚠ Regenerated name '{new_name}' is still a duplicate in card_names")
-                            raise ValueError("Regenerated name is still a duplicate")
-                        if new_name in batch_names:
-                            print(f"⚠ Regenerated name '{new_name}' conflicts with another card in this batch")
-                            raise ValueError("Regenerated name conflicts with batch")
-                        card.Name = new_name
-                    except Exception as e:
-                        print(f"⚠ Failed to generate replacement name: {e}")
-                        # Continue to next attempt
-                        raise ValueError("Failed to generate unique name")
+                    # Keep trying to generate a unique name until one is found
+                    max_name_attempts = 10  # Try up to 10 times to generate a unique name
+                    name_found = False
+                    for name_attempt in range(max_name_attempts):
+                        try:
+                            # Combine existing names and current batch names to avoid duplicates
+                            all_used_names = card_names | batch_names
+                            new_name = generate_unique_name_for_card(
+                                parsed_card=card,
+                                used_names=all_used_names,
+                                extract_model=extract_model,
+                            )
+                            # Verify the regenerated name is actually unique
+                            if new_name in card_names:
+                                print(f"⚠ Regenerated name '{new_name}' (attempt {name_attempt + 1}) is still a duplicate in card_names, retrying...")
+                                continue  # Try again
+                            if new_name in batch_names:
+                                print(f"⚠ Regenerated name '{new_name}' (attempt {name_attempt + 1}) conflicts with another card in this batch, retrying...")
+                                continue  # Try again
+                            # Unique name found!
+                            card.Name = new_name
+                            # Track the name change
+                            if original_name != new_name:
+                                name_mappings[original_name] = new_name
+                            name_found = True
+                            break
+                        except Exception as e:
+                            print(f"⚠ Failed to generate replacement name (attempt {name_attempt + 1}): {e}")
+                            if name_attempt == max_name_attempts - 1:
+                                # Last attempt failed, give up and retry entire card generation
+                                raise ValueError("Failed to generate unique name after multiple attempts")
+                            continue  # Try again
+                    
+                    if not name_found:
+                        raise ValueError("Failed to generate unique name after multiple attempts")
                 
                 # Check if name is duplicate within the current batch
                 if card.Name in batch_names:
-                    try:
-                        # Combine existing names and current batch names to avoid duplicates
-                        all_used_names = card_names | batch_names
-                        new_name = generate_unique_name_for_card(
-                            parsed_card=card,
-                            used_names=all_used_names,
-                            extract_model=extract_model,
-                        )
-                        # Verify the regenerated name is actually unique
-                        if new_name in card_names:
-                            print(f"⚠ Regenerated name '{new_name}' is still a duplicate in card_names")
-                            raise ValueError("Regenerated name is still a duplicate")
-                        if new_name in batch_names:
-                            print(f"⚠ Regenerated name '{new_name}' conflicts with another card in this batch")
-                            raise ValueError("Regenerated name conflicts with batch")
-                        card.Name = new_name
-                    except Exception as e:
-                        print(f"⚠ Failed to generate replacement name for batch duplicate: {e}")
-                        # Continue to next attempt
-                        raise ValueError("Failed to generate unique name")
+                    # Keep trying to generate a unique name until one is found
+                    max_name_attempts = 10  # Try up to 10 times to generate a unique name
+                    name_found = False
+                    for name_attempt in range(max_name_attempts):
+                        try:
+                            # Combine existing names and current batch names to avoid duplicates
+                            all_used_names = card_names | batch_names
+                            new_name = generate_unique_name_for_card(
+                                parsed_card=card,
+                                used_names=all_used_names,
+                                extract_model=extract_model,
+                            )
+                            # Verify the regenerated name is actually unique
+                            if new_name in card_names:
+                                print(f"⚠ Regenerated name '{new_name}' (attempt {name_attempt + 1}) is still a duplicate in card_names, retrying...")
+                                continue  # Try again
+                            if new_name in batch_names:
+                                print(f"⚠ Regenerated name '{new_name}' (attempt {name_attempt + 1}) conflicts with another card in this batch, retrying...")
+                                continue  # Try again
+                            # Unique name found!
+                            card.Name = new_name
+                            # Track the name change
+                            if original_name != new_name:
+                                name_mappings[original_name] = new_name
+                            name_found = True
+                            break
+                        except Exception as e:
+                            print(f"⚠ Failed to generate replacement name for batch duplicate (attempt {name_attempt + 1}): {e}")
+                            if name_attempt == max_name_attempts - 1:
+                                # Last attempt failed, give up and retry entire card generation
+                                raise ValueError("Failed to generate unique name after multiple attempts")
+                            continue  # Try again
+                    
+                    if not name_found:
+                        raise ValueError("Failed to generate unique name after multiple attempts")
                 
                 # Add the (now unique) name to batch tracking
                 batch_names.add(card.Name)
+            
+            # Update explanation with new card names if any cards were renamed
+            if name_mappings:
+                explanation = original_explanation
+                # Replace old names with new names in the explanation
+                # Sort by length (longest first) to handle cases where one name contains another
+                sorted_mappings = sorted(name_mappings.items(), key=lambda x: len(x[0]), reverse=True)
+                for old_name, new_name in sorted_mappings:
+                    # Use word boundaries to replace whole words only
+                    escaped_old_name = re.escape(old_name)
+                    pattern = r'\b' + escaped_old_name + r'\b'
+                    explanation = re.sub(pattern, new_name, explanation)
+                # Update parsed_list.explanation so clean_explanation_quotes uses the updated version
+                parsed_list.explanation = explanation
+            else:
+                explanation = original_explanation
+            
+            # Clean the explanation to remove quotes around card names (after updating names)
+            # Note: parsed_list.cards already have the updated names since they're the same objects
+            explanation = clean_explanation_quotes(parsed_list, card_model)
 
             # Success - format all cards (without explanation)
             formatted_cards = []