Upload app.py

app.py

@@ -0,0 +1,1566 @@
+#!/usr/bin/env python3
+"""
+Web Demo v2 pour la base de données d'œuvres d'art - Version Sécurisée et Optimisée
+Interface multi-étapes avec matching basé sur prénom, date, ville et émotions
+Optimisé pour les performances avec caching et indexation
+Version sécurisée avec validation des entrées et gestion d'état propre
+"""
+
+import gradio as gr
+import os
+import sys
+import logging
+from logging.handlers import RotatingFileHandler
+import random
+import re
+import json
+import uuid
+import time
+from datetime import datetime
+from typing import List, Dict, Tuple, Optional, Any, Set
+from collections import Counter, defaultdict
+from functools import lru_cache
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+import pandas as pd
+
+# Configuration du logging principal
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s] %(levelname)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+# Import pour la sauvegarde persistante sur HF Spaces
+try:
+    from huggingface_hub import CommitScheduler
+
+    HF_HUB_AVAILABLE = True
+except ImportError:
+    HF_HUB_AVAILABLE = False
+    logger.warning(
+        "huggingface_hub non installé - Les logs ne seront pas sauvegardés dans un dataset HF"
+    )
+
+# Configuration du logging des sessions
+SESSION_LOG_FILE = "session_logs.jsonl"
+STATS_LOG_FILE = "statistics.json"
+
+# Configuration du dataset HF pour la persistance (modifiez ces valeurs)
+HF_DATASET_ID = os.environ.get(
+    "HF_DATASET_ID", "ClickMons/art-matcher-logs"
+)  # Remplacez par votre dataset
+HF_TOKEN = os.environ.get("HF_TOKEN", None)  # Token HF pour l'authentification
+LOGS_UPLOAD_INTERVAL = 10  # Upload toutes les 10 minutes
+
+# Créer un handler pour le fichier de logs des sessions (local)
+if not os.path.exists("logs"):
+    os.makedirs("logs")
+
+session_file_handler = RotatingFileHandler(
+    filename=os.path.join("logs", SESSION_LOG_FILE),
+    maxBytes=10 * 1024 * 1024,  # 10MB
+    backupCount=5,
+    encoding="utf-8",
+)
+session_file_handler.setLevel(logging.INFO)
+session_logger = logging.getLogger("session_logger")
+session_logger.addHandler(session_file_handler)
+session_logger.setLevel(logging.INFO)
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+from art_pieces_db.database import Database
+from art_pieces_db.query import TargetProfile, WeightedLeximaxOptimizer, Optimizer
+from art_pieces_db.emotions import EmotionWheel
+from art_pieces_db.utils import str_to_date
+
+
+@dataclass
+class ScoringWeights:
+    """Centralise toutes les constantes de scoring pour éviter les magic numbers"""
+
+    PRESELECTION_NAME_WEIGHT: float = 3.0
+    PRESELECTION_DATE_WEIGHT: float = 1.0
+    PRESELECTION_PLACE_WEIGHT: float = 2.0
+    PRESELECTION_EMOTION_WEIGHT: float = 0.0
+
+    MIN_PRESELECTION_COUNT: int = 20
+    MAX_IMAGES_PER_SELECTION: int = 3  # nombre d'images par sélection
+    TOTAL_ROUNDS: int = 3  # nombre de rounds avant la recommandation finale
+
+
+@dataclass
+class SessionState:
+    """Gère l'état de session"""
+
+    firstname: str = ""
+    birthday: str = ""
+    city: str = ""
+
+    current_round: int = 0
+    selected_images: List[str] = field(default_factory=list)
+    current_image_ids: List[str] = field(default_factory=list)
+
+    preselected_pieces: Optional[pd.DataFrame] = None
+
+    # Propriétés pour le tracking
+    session_start_time: float = field(default_factory=time.time)
+    recommendation_type: str = ""  # "name_date_place" ou "emotions"
+    final_artwork: str = ""
+
+    def reset(self):
+        """Réinitialise l'état de session"""
+        self.firstname = ""
+        self.birthday = ""
+        self.city = ""
+        self.current_round = 0
+        self.selected_images = []
+        self.current_image_ids = []
+        self.preselected_pieces = None
+        self.session_start_time = time.time()
+        self.recommendation_type = ""
+        self.final_artwork = ""
+
+    def is_complete(self) -> bool:
+        """Vérifie si la sélection est complète"""
+        return self.current_round >= ScoringWeights.TOTAL_ROUNDS
+
+
+class SessionLogger:
+    """Version améliorée du logger de sessions avec CommitScheduler simplifié"""
+
+    def __init__(self):
+        # Détection de l'environnement HF Spaces
+        self.is_hf_space = os.environ.get("SPACE_ID") is not None
+
+        # Configuration du répertoire de données
+        self.data_dir = Path("art_matcher_data")
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+        # Un seul fichier unique par instance du Space (comme Wauplin)
+        self.instance_id = uuid.uuid4()
+        self.sessions_file = self.data_dir / f"sessions_{self.instance_id}.jsonl"
+        self.stats_file = self.data_dir / "global_statistics.json"
+
+        # Initialiser le CommitScheduler si sur HF Spaces
+        self.scheduler = None
+        if self.is_hf_space and HF_HUB_AVAILABLE:
+            try:
+                # Configuration simplifiée - pas besoin de HF_TOKEN explicite sur Spaces
+                self.scheduler = CommitScheduler(
+                    repo_id=HF_DATASET_ID,  # Utilise la variable existante
+                    repo_type="dataset",
+                    folder_path=self.data_dir,
+                    path_in_repo="data",
+                    every=LOGS_UPLOAD_INTERVAL,  # Utilise la variable existante
+                )
+                logger.info(
+                    f"✅ CommitScheduler initialisé - Instance ID: {self.instance_id}"
+                )
+                logger.info(
+                    f"Les données seront automatiquement sauvegardées dans {HF_DATASET_ID}"
+                )
+            except Exception as e:
+                logger.warning(f"⚠️ CommitScheduler non disponible: {e}")
+                logger.info("Les données seront stockées localement uniquement")
+
+    def log_session(self, state: SessionState, recommendation_system: str):
+        """Enregistre une session de manière thread-safe"""
+        session_duration = time.time() - state.session_start_time
+
+        entry = {
+            "session_id": str(self.instance_id),
+            "datetime": datetime.now().isoformat(),
+            "duration_seconds": round(session_duration, 2),
+            "recommended_artwork": state.final_artwork,
+            "recommendation_type": recommendation_system,
+        }
+
+        # Utiliser le lock du scheduler pour la thread safety
+        if self.scheduler:
+            with self.scheduler.lock:
+                self._write_session(entry)
+                self._update_stats(entry)
+        else:
+            # Sans scheduler, écriture directe
+            self._write_session(entry)
+            self._update_stats(entry)
+
+        logger.info(f"Session enregistrée - Durée: {entry['duration_seconds']}s")
+        session_logger.info(json.dumps(entry, ensure_ascii=False))
+
+    def _write_session(self, entry: dict):
+        """Écrit une entrée de session dans le fichier JSONL"""
+        with self.sessions_file.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    def _update_stats(self, session_entry: dict):
+        """Met à jour les statistiques globales"""
+        # Charger les stats existantes
+        stats = {}
+        if self.stats_file.exists():
+            try:
+                with self.stats_file.open("r", encoding="utf-8") as f:
+                    stats = json.load(f)
+            except json.JSONDecodeError:
+                stats = {}
+
+        # Initialiser la structure si nécessaire
+        if "total_sessions" not in stats:
+            stats = {
+                "total_sessions": 0,
+                "total_duration_seconds": 0,
+                "average_duration_seconds": 0,
+                "artworks_recommended": {},
+                "recommendation_types": {
+                    "name_date_place": 0,
+                    "emotions": 0,
+                    "none": 0,
+                },
+                "first_session": session_entry["datetime"],
+                "last_session": session_entry["datetime"],
+            }
+
+        # Mettre à jour les compteurs
+        stats["total_sessions"] += 1
+        stats["total_duration_seconds"] += session_entry.get("duration_seconds", 0)
+        stats["average_duration_seconds"] = (
+            stats["total_duration_seconds"] / stats["total_sessions"]
+        )
+        stats["last_session"] = session_entry["datetime"]
+
+        # Compter les types de recommandation
+        rec_type = session_entry.get("recommendation_type", "none")
+        if rec_type in stats["recommendation_types"]:
+            stats["recommendation_types"][rec_type] += 1
+
+        # Compter les œuvres recommandées
+        artwork = session_entry.get("recommended_artwork")
+        if artwork and artwork != "Aucune œuvre trouvée":
+            if artwork not in stats["artworks_recommended"]:
+                stats["artworks_recommended"][artwork] = 0
+            stats["artworks_recommended"][artwork] += 1
+
+        # Trouver l'œuvre la plus populaire
+        if stats["artworks_recommended"]:
+            most_popular = max(
+                stats["artworks_recommended"].items(), key=lambda x: x[1]
+            )
+            stats["most_popular_artwork"] = {
+                "title": most_popular[0],
+                "count": most_popular[1],
+                "percentage": (most_popular[1] / stats["total_sessions"]) * 100,
+            }
+
+        # Calculer les pourcentages d'utilisation
+        total = stats["total_sessions"]
+        if total > 0:
+            stats["recommendation_percentages"] = {
+                k: (v / total) * 100 for k, v in stats["recommendation_types"].items()
+            }
+
+        stats["last_updated"] = datetime.now().isoformat()
+
+        # Sauvegarder les stats mises à jour
+        with self.stats_file.open("w", encoding="utf-8") as f:
+            json.dump(stats, f, indent=2, ensure_ascii=False)
+
+    def get_statistics(self) -> dict:
+        """Retourne les statistiques globales"""
+        if self.stats_file.exists():
+            try:
+                with self.stats_file.open("r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception as e:
+                logger.error(f"Erreur lecture stats: {e}")
+        return {}
+
+
+# Initialiser le logger de sessions
+session_tracker = SessionLogger()
+
+
+class SecurityValidator:
+    """Classe pour centraliser les validations de sécurité"""
+
+    PATH_TRAVERSAL_PATTERN = re.compile(r"\.\.|\.\/")
+    VALID_FILENAME_PATTERN = re.compile(r"^[\w\-\.\s]+$")
+    VALID_INPUT_PATTERN = re.compile(
+        r"^[\w\-\s\'\.,àâäéèêëïîôûùüÿæœçÀÂÄÉÈÊËÏÎÔÛÙÜŸÆŒÇ]+$", re.UNICODE
+    )
+    DATE_PATTERN = re.compile(r"^\d{1,2}/\d{1,2}$")
+
+    @classmethod
+    def validate_filename(cls, filename: str) -> bool:
+        """Valide qu'un nom de fichier est sécurisé"""
+        if not filename:
+            return False
+
+        # Vérifier les tentatives de path traversal
+        if cls.PATH_TRAVERSAL_PATTERN.search(filename):
+            logger.warning(f"Tentative de path traversal détectée: {filename}")
+            return False
+
+        # Vérifier que le nom ne contient que des caractères autorisés
+        base_name = os.path.basename(filename)
+        if not cls.VALID_FILENAME_PATTERN.match(base_name):
+            logger.warning(f"Nom de fichier invalide: {filename}")
+            return False
+
+        return True
+
+    @classmethod
+    def sanitize_input(cls, input_str: str, max_length: int = 100) -> str:
+        """Nettoie et valide une entrée utilisateur"""
+        if not input_str:
+            return ""
+
+        # Tronquer si trop long
+        input_str = input_str[:max_length].strip()
+
+        if not cls.VALID_INPUT_PATTERN.match(input_str):
+            # Garder seulement les caractères valides
+            cleaned = "".join(c for c in input_str if cls.VALID_INPUT_PATTERN.match(c))
+            logger.info(f"Input sanitized: '{input_str}' -> '{cleaned}'")
+            return cleaned
+
+        return input_str
+
+    @classmethod
+    def validate_date(cls, date_str: str) -> Tuple[bool, Optional[datetime]]:
+        """Valide et parse une date au format JJ/MM"""
+        if not date_str:
+            return False, None
+
+        if not cls.DATE_PATTERN.match(date_str):
+            return False, None
+
+        try:
+            day, month = map(int, date_str.split("/"))
+            if not (1 <= day <= 31 and 1 <= month <= 12):
+                return False, None
+
+            date_obj = datetime(year=2000, month=month, day=day)
+            return True, date_obj
+        except (ValueError, Exception) as e:
+            logger.error(f"Erreur de parsing de date: {e}")
+            return False, None
+
+
+class ImageIndexer:
+    """Classe pour indexer et mapper les images depuis la base de données CSV"""
+
+    # Constants for better maintainability
+    IMAGE_EXTENSIONS = (".jpg", ".png")
+    COMMON_SUFFIXES = [".jpg", ".png", "_medium"]
+    MAR_BVM_TEST_SUFFIXES = ["-001", "-002", "-003"]
+
+    def __init__(self, images_dir: str):
+        self.images_dir = os.path.abspath(images_dir)
+        self.available_files = set()
+        self.image_lookup = {}  # normalized_name -> filename
+        self.mar_bvm_lookup = {}  # Special handling for MAR-BVM files
+        self._build_index()
+
+    def _strip_file_extensions(self, filename: str) -> str:
+        """Remove file extensions from filename"""
+        base_name = filename.lower()
+        if base_name.endswith("_medium.jpg"):
+            return base_name[:-11]
+        elif base_name.endswith((".jpg", ".png")):
+            return base_name[:-4]
+        return base_name
+
+    def _normalize_basic_patterns(self, name: str) -> str:
+        """Apply basic normalization patterns"""
+        # Remove trailing comma and normalize whitespace
+        normalized = name.lower().strip().rstrip(",")
+
+        # Remove common suffixes
+        for suffix in self.COMMON_SUFFIXES:
+            if normalized.endswith(suffix):
+                normalized = normalized[: -len(suffix)]
+
+        # Normalize spaces and underscores to dashes
+        return re.sub(r"[\s_]+", "-", normalized)
+
+    def _normalize_mar_bvm_format(self, name: str) -> str:
+        """Handle MAR-BVM specific normalization"""
+        if "mar-bvm" not in name:
+            return name
+
+        # Replace .0. with -0- and remaining dots with dashes
+        return name.replace(".0.", "-0-").replace(".", "-")
+
+    def _normalize_name(self, name: str) -> str:
+        """Normalise un nom pour la comparaison"""
+        normalized = self._normalize_basic_patterns(name)
+
+        # Special handling for MAR-BVM format
+        if "mar-bvm" in normalized:
+            normalized = self._normalize_mar_bvm_format(normalized)
+        # For files starting with year (like 2022.0.86), keep dots
+        elif not normalized.startswith("20"):
+            normalized = normalized.replace(".", "-")
+
+        return normalized
+
+    def _create_mar_bvm_lookups(self, normalized: str, filename: str):
+        """Create additional lookup entries for MAR-BVM files"""
+        if "mar-bvm" not in normalized:
+            return
+
+        parts = normalized.split("-")
+        for i, part in enumerate(parts):
+            if part.isdigit() and i >= 5:  # After mar-bvm-7-2022-0
+                base_key = "-".join(parts[:6])  # mar-bvm-7-2022-0-22
+                if base_key not in self.mar_bvm_lookup:
+                    self.mar_bvm_lookup[base_key] = []
+                self.mar_bvm_lookup[base_key].append(filename)
+                break
+
+    def _process_image_file(self, filename: str):
+        """Process a single image file for indexing"""
+        if not SecurityValidator.validate_filename(filename):
+            logger.warning(f"Fichier ignoré pour raison de sécurité: {filename}")
+            return
+
+        if not filename.lower().endswith(self.IMAGE_EXTENSIONS):
+            return
+
+        self.available_files.add(filename)
+
+        base_name = self._strip_file_extensions(filename)
+        normalized = self._normalize_name(base_name)
+        self.image_lookup[normalized] = filename
+        self._create_mar_bvm_lookups(normalized, filename)
+
+    def _build_index(self):
+        """Construit un index des images disponibles"""
+        try:
+            all_files = os.listdir(self.images_dir)
+            for filename in all_files:
+                self._process_image_file(filename)
+
+            logger.info(
+                f"Index des images construit: {len(self.available_files)} fichiers disponibles, "
+                f"{len(self.image_lookup)} entrées normalisées"
+            )
+        except Exception as e:
+            logger.error(f"Erreur lors de la construction de l'index: {e}")
+            self.available_files = set()
+
+    def _clean_input_name(self, image_name: str) -> str:
+        """Clean and prepare input name for processing"""
+        # Basic cleaning
+        cleaned = image_name.strip().rstrip(",").rstrip("-").strip()
+        # Remove spaces before -001, -002, etc.
+        return re.sub(r"\s+(-\d)", r"\1", cleaned)
+
+    def _normalize_mar_bvm_input(self, image_name: str) -> str:
+        """Handle MAR-BVM specific input normalization"""
+        if "MAR-BVM" not in image_name:
+            return image_name
+
+        # Handle missing "7-" in MAR-BVM-2022-0-153
+        if "MAR-BVM-2022-0-" in image_name:
+            image_name = image_name.replace("MAR-BVM-2022-0-", "MAR-BVM-7-2022-0-")
+
+        # Convert .0. to -0-
+        if ".0." in image_name:
+            image_name = image_name.replace(".0.", "-0-")
+
+        # Handle .001, .002 at the end (convert to -001, -002)
+        image_name = re.sub(r"\.(\d{3})$", r"-\1", image_name)
+
+        # Handle .1 or .2 suffix
+        if image_name.endswith(".1"):
+            image_name = image_name[:-2] + "-1"
+        elif image_name.endswith(".2"):
+            image_name = image_name[:-2] + "-2"
+
+        # Replace any remaining dots with dashes (but be careful not to mess up already processed parts)
+        return image_name.replace(".", "-")
+
+    def _try_mar_bvm_lookups(self, normalized: str) -> Optional[str]:
+        """Try various MAR-BVM specific lookup strategies"""
+        # Check special MAR-BVM lookup
+        if normalized in self.mar_bvm_lookup and self.mar_bvm_lookup[normalized]:
+            return self.mar_bvm_lookup[normalized][0]
+
+        # Try with suffix variations
+        for suffix in self.MAR_BVM_TEST_SUFFIXES:
+            test_pattern = f"{normalized}{suffix}"
+            if test_pattern in self.image_lookup:
+                return self.image_lookup[test_pattern]
+
+        return None
+
+    def _try_year_format_lookup(self, image_name: str) -> Optional[str]:
+        """Handle special case for files starting with year"""
+        if not image_name.startswith("20"):
+            return None
+
+        test_name = image_name.lower().replace(" ", "-")
+        return self.image_lookup.get(test_name)
+
+    def _try_partial_matching(self, normalized: str) -> Optional[str]:
+        """Try partial matching as last resort"""
+        for key, filename in self.image_lookup.items():
+            if key.startswith(normalized) or normalized in key:
+                return filename
+        return None
+
+    def _split_multiple_names(self, image_name: str) -> List[str]:
+        """Split image names that contain multiple names separated by commas or slashes"""
+        # First try comma separation
+        if "," in image_name:
+            return [name.strip() for name in image_name.split(",") if name.strip()]
+
+        # Then try slash separation
+        if "/" in image_name:
+            return [name.strip() for name in image_name.split("/") if name.strip()]
+
+        # Handle " - " separation (for cases like "MAR-BVM-7-2022.0.81 - 2022.0.81")
+        if " - " in image_name and image_name.count(" - ") == 1:
+            parts = [name.strip() for name in image_name.split(" - ")]
+            # Only use the first part if they look like duplicates
+            if len(parts) == 2:
+                first, second = parts
+                # Check if second part is a suffix of the first (like duplicate year)
+                if first.endswith(second) or second in first:
+                    return [first]
+                return parts
+
+        return [image_name]
+
+    def find_image(self, image_name: str) -> Optional[str]:
+        """Trouve un fichier image correspondant au nom donné"""
+        if not image_name:
+            return None
+
+        # Handle multiple image names in one field
+        possible_names = self._split_multiple_names(image_name)
+
+        # Try each name individually
+        for name in possible_names:
+            result = self._find_single_image(name)
+            if result:
+                return result
+
+        return None
+
+    def _find_single_image(self, image_name: str) -> Optional[str]:
+        """Find a single image by name"""
+        # Clean and normalize the input
+        cleaned_name = self._clean_input_name(image_name)
+        processed_name = self._normalize_mar_bvm_input(cleaned_name)
+        normalized = self._normalize_name(processed_name)
+
+        # Try direct lookup first
+        if normalized in self.image_lookup:
+            return self.image_lookup[normalized]
+
+        # Try MAR-BVM specific lookups
+        if "mar-bvm" in normalized:
+            result = self._try_mar_bvm_lookups(normalized)
+            if result:
+                return result
+
+        # Try year format lookup
+        result = self._try_year_format_lookup(image_name)
+        if result:
+            return result
+
+        # Try partial matching as last resort
+        return self._try_partial_matching(normalized)
+
+    def get_all_files(self) -> Set[str]:
+        """Retourne tous les fichiers disponibles"""
+        return self.available_files.copy()
+
+
+class ArtMatcherV2:
+    """Classe principale pour le matching d'œuvres d'art"""
+
+    def __init__(self, csv_path: str, images_dir: str):
+        """Initialise le système avec la base de données et le répertoire d'images"""
+        self.db = Database(csv_path)
+        self.images_dir = os.path.abspath(images_dir)
+        self.emotion_wheel = EmotionWheel()
+        self.weights = ScoringWeights()
+
+        self.optimizer_helper = WeightedLeximaxOptimizer(TargetProfile(), {})
+
+        self.image_indexer = ImageIndexer(images_dir)
+
+        df = self.db.get_dataframe()
+        self.df_with_images = df[
+            df["name_image"].notna()
+            & (df["name_image"] != "")
+            & (df["name_image"].str.strip() != "")
+        ].copy()
+
+        self.df_with_images["database_id_str"] = self.df_with_images[
+            "database_id"
+        ].astype(str)
+        self.id_to_index = {
+            str(row["database_id"]): idx for idx, row in self.df_with_images.iterrows()
+        }
+
+        self.artwork_images = self._build_artwork_image_index()
+
+        self.temp_db_with_images = Database.__new__(Database)
+        self.temp_db_with_images.dataframe = self.df_with_images
+
+        logger.info(f"Base de données chargée: {self.db.n_pieces()} œuvres")
+        logger.info(f"Œuvres avec images: {len(self.df_with_images)}")
+        logger.info(f"Index des images: {len(self.artwork_images)} œuvres mappées")
+
+    def _sanitize_input(self, input_str: str) -> str:
+        """Nettoie et valide une entrée utilisateur"""
+        return SecurityValidator.sanitize_input(input_str)
+
+    def _parse_date(self, date_str: str) -> Optional[datetime]:
+        """Parse une date avec validation"""
+        is_valid, date_obj = SecurityValidator.validate_date(date_str)
+        return date_obj if is_valid else None
+
+    def _build_artwork_image_index(self) -> Dict[str, List[str]]:
+        """Construit un index artwork_id -> [image_paths] au démarrage"""
+        artwork_images = {}
+
+        for idx, row in self.df_with_images.iterrows():
+            artwork_id = str(row["database_id"])
+            image_paths = []
+
+            if row["name_image"] and str(row["name_image"]).strip():
+                # Parse the image names - handle special separators
+                image_string = str(row["name_image"]).strip().strip('"')
+
+                # Handle cases with " / " or " - " separators
+                if " / " in image_string:
+                    # Take first part before the slash
+                    image_string = image_string.split(" / ")[0].strip()
+
+                # Special case: if it has " - 2022" it's a separator, not part of the name
+                if " - 2022" in image_string:
+                    # Take the part before " - 2022"
+                    image_string = image_string.split(" - 2022")[0].strip()
+                elif " - " in image_string and "MAR-BVM-7-2022-0-" not in image_string:
+                    # For other MAR-BVM formats with " - " separator
+                    parts = image_string.split(" - ")
+                    if "MAR-BVM" in parts[0]:
+                        image_string = parts[0].strip()
+
+                # Clean up trailing " -" or spaces before "-001"
+                image_string = re.sub(
+                    r"\s+-\s*$", "", image_string
+                )  # Remove trailing " -"
+                image_string = re.sub(
+                    r"\s+(-\d)", r"\1", image_string
+                )  # Remove spaces before -001
+
+                # Parse comma-separated list
+                images = [
+                    img.strip()
+                    for img in re.split(r"[,/]", image_string)
+                    if img.strip()
+                ]
+
+                for img_name in images:
+                    # Find the actual file for this image name
+                    matched_file = self.image_indexer.find_image(img_name)
+                    if matched_file:
+                        img_path = os.path.join(self.images_dir, matched_file)
+                        image_paths.append(img_path)
+
+            if image_paths:
+                artwork_images[artwork_id] = image_paths
+
+        return artwork_images
+
+    def preselect_artworks(
+        self, firstname: str, birthday: str, city: str
+    ) -> pd.DataFrame:
+        """
+        Pré-sélectionne les œuvres selon la hiérarchie: prénom > date > ville
+        """
+        logger.info("=== DÉBUT PRÉ-SÉLECTION ===")
+
+        # Nettoyer les entrées
+        firstname = self._sanitize_input(firstname)
+        city = self._sanitize_input(city)
+
+        logger.info(
+            f"Critères de pré-sélection: prénom='{firstname}', date='{birthday}', ville='{city}'"
+        )
+
+        birth_date = self._parse_date(birthday)
+        if birth_date:
+            logger.info(f"Date convertie: {birth_date.strftime('%d/%m')}")
+
+        profile = TargetProfile()
+        profile.set_target_name(firstname)
+        profile.set_target_date(birth_date)
+        profile.set_target_place(city)
+
+        weights = {
+            "related_names": self.weights.PRESELECTION_NAME_WEIGHT,
+            "related_dates": self.weights.PRESELECTION_DATE_WEIGHT,
+            "related_places": self.weights.PRESELECTION_PLACE_WEIGHT,
+            "related_emotions": self.weights.PRESELECTION_EMOTION_WEIGHT,
+        }
+
+        logger.info(
+            f"Poids utilisés: nom={weights['related_names']}, date={weights['related_dates']}, lieu={weights['related_places']}, émotions={weights['related_emotions']}"
+        )
+
+        optimizer = WeightedLeximaxOptimizer(profile, weights)
+        result = optimizer.optimize_max(self.temp_db_with_images)
+
+        preselected = result[result["score"] > (0, 0, 0)]
+        logger.info(f"Œuvres avec score > 0: {len(preselected)}")
+
+        if len(preselected) < self.weights.MIN_PRESELECTION_COUNT:
+            preselected = result.head(self.weights.MIN_PRESELECTION_COUNT)
+            logger.info(f"Ajustement au minimum requis: {len(preselected)} œuvres")
+
+        logger.info("Top 5 pré-sélections:")
+        for i, (idx, piece) in enumerate(preselected.head(5).iterrows()):
+            logger.info(
+                f"  {i+1}. Œuvre #{piece['database_id']} - Score: {piece['score']}"
+            )
+            if firstname and piece["related_names"]:
+                name_score = Optimizer.name_similarity(
+                    firstname, piece["related_names"]
+                )
+                if name_score > 0:
+                    logger.info(
+                        f"     → Nom: {piece['related_names']} (score: {name_score:.2f})"
+                    )
+            if birth_date and piece["related_dates"]:
+                date_score = Optimizer.date_similarity(
+                    birth_date, piece["related_dates"]
+                )
+                if date_score > 0:
+                    logger.info(
+                        f"     → Dates: {[d.strftime('%d/%m') for d in piece['related_dates']]} (score: {date_score:.2f})"
+                    )
+            if city and piece["related_places"]:
+                place_score = self.optimizer_helper.place_similarity(
+                    city, piece["related_places"]
+                )
+                if place_score > 0:
+                    logger.info(
+                        f"     → Lieux: {piece['related_places']} (score: {place_score:.2f})"
+                    )
+
+        logger.info("=== FIN PRÉ-SÉLECTION ===")
+        return preselected
+
+    def get_random_images_for_selection(
+        self, round_num: int, already_selected: List[str] = None
+    ) -> List[Tuple[str, str]]:
+        """
+        Retourne 3 images aléatoires depuis l'index pré-construit
+        Exclut les œuvres déjà sélectionnées dans les tours précédents
+        """
+        logger.info(f"=== SÉLECTION D'IMAGES POUR LE TOUR {round_num} ===")
+
+        if already_selected:
+            logger.info(f"Œuvres déjà sélectionnées à exclure: {already_selected}")
+
+        available_artworks = list(self.artwork_images.keys())
+
+        # Exclure les œuvres déjà sélectionnées
+        if already_selected:
+            already_selected_set = set(already_selected)
+            available_artworks = [
+                a for a in available_artworks if a not in already_selected_set
+            ]
+
+        logger.info(
+            f"Nombre total d'œuvres avec images disponibles: {len(available_artworks)}"
+        )
+
+        if len(available_artworks) < self.weights.MAX_IMAGES_PER_SELECTION:
+            logger.warning(
+                f"Seulement {len(available_artworks)} œuvres avec images disponibles"
+            )
+            direct_images = []
+            for filename in list(self.image_indexer.get_all_files())[:10]:
+                if filename.endswith(".jpg"):
+                    img_path = os.path.join(self.images_dir, filename)
+                    direct_images.append((img_path, "0"))
+            return direct_images[: self.weights.MAX_IMAGES_PER_SELECTION]
+
+        num_to_select = min(
+            self.weights.MAX_IMAGES_PER_SELECTION, len(available_artworks)
+        )
+        selected_artworks = random.sample(available_artworks, num_to_select)
+
+        logger.info(f"Œuvres sélectionnées aléatoirement: {selected_artworks}")
+
+        selected = []
+        for artwork_id in selected_artworks:
+            img_path = random.choice(self.artwork_images[artwork_id])
+            selected.append((img_path, artwork_id))
+            if artwork_id in self.id_to_index:
+                idx = self.id_to_index[artwork_id]
+                artwork = self.df_with_images.loc[idx]
+                logger.info(f"  Image {len(selected)}: Œuvre #{artwork_id}")
+                logger.info(f"    Type: {artwork['art_piece_type']}")
+                logger.info(f"    Émotions: {artwork['related_emotions']}")
+
+        logger.info(f"=== FIN SÉLECTION IMAGES TOUR {round_num} ===")
+        return selected
+
+    def extract_emotions_from_image_id(self, database_id: str) -> List[str]:
+        """
+        Extrait les émotions associées à une œuvre via son ID
+        Utilise l'index pré-calculé pour éviter les conversions répétées
+        """
+        if database_id in self.id_to_index:
+            idx = self.id_to_index[database_id]
+            emotions = self.df_with_images.loc[idx, "related_emotions"]
+            if isinstance(emotions, list):
+                return emotions
+        return []
+
+    @lru_cache(maxsize=1024)
+    def _cached_emotion_similarity(self, emotion1: str, emotion2: str) -> float:
+        """Cache les calculs de similarité émotionnelle"""
+        return self.emotion_wheel.calculate_emotion_similarity(emotion1, emotion2)
+
+    def calculate_emotion_profile(self, selected_ids: List[str]) -> Dict[str, float]:
+        """
+        Calcule le profil émotionnel basé sur les images sélectionnées
+        """
+        logger.info("=== CALCUL DU PROFIL ÉMOTIONNEL ===")
+        logger.info(f"Images sélectionnées: {selected_ids}")
+
+        emotion_counter = Counter()
+
+        for db_id in selected_ids:
+            emotions = self.extract_emotions_from_image_id(db_id)
+            logger.info(f"  Image {db_id}: émotions = {emotions}")
+            emotion_counter.update(emotions)
+
+        total = sum(emotion_counter.values())
+        if total > 0:
+            emotion_profile = {
+                emotion: count / total for emotion, count in emotion_counter.items()
+            }
+            logger.info(f"Profil émotionnel calculé: {emotion_profile}")
+        else:
+            emotion_profile = {}
+            logger.info("Aucune émotion trouvée dans les images sélectionnées")
+
+        logger.info("=== FIN CALCUL PROFIL ÉMOTIONNEL ===")
+        return emotion_profile
+
+    def _get_artwork_image(self, artwork) -> Optional[str]:
+        """Retourne le chemin de l'image pour une œuvre d'art"""
+        artwork_id = str(artwork["database_id"])
+
+        # Simply return the first image from our pre-built index
+        if artwork_id in self.artwork_images:
+            return self.artwork_images[artwork_id][0]
+
+        return None
+
+    def find_best_match(
+        self, firstname: str, birthday: str, city: str, selected_image_ids: List[str]
+    ) -> Tuple[Optional[str], str, Dict]:
+        """
+        Trouve la meilleure correspondance selon la hiérarchie du scénario:
+        1. Match exact (name/date/city) = gagnant automatique
+        2. Si pré-sélection existe: utiliser émotions pour départager
+        3. Si aucune pré-sélection: utiliser émotions seules
+        4. Type d'objet comme critère de départage final
+        """
+        firstname = self._sanitize_input(firstname)
+        city = self._sanitize_input(city)
+        birth_date = self._parse_date(birthday)
+
+        logger.info(
+            f"Recherche de correspondance pour: {firstname}, {birthday}, {city}"
+        )
+
+        preselected = self.preselect_artworks(firstname, birthday, city)
+
+        logger.info("=== DÉTECTION DE MATCH EXACT ===")
+        for idx, piece in preselected.iterrows():
+            if firstname and piece["related_names"]:
+                name_score = Optimizer.name_similarity(
+                    firstname, piece["related_names"]
+                )
+                if name_score >= 0.95:
+                    logger.info(
+                        f"🎯 MATCH EXACT TROUVÉ: prénom '{firstname}' → œuvre #{piece['database_id']} (score: {name_score:.2f})"
+                    )
+                    logger.info(f"   Noms dans l'œuvre: {piece['related_names']}")
+                    match_image = self._get_artwork_image(piece)
+                    match_info = {
+                        "title": f"Œuvre #{piece['database_id']}",
+                        "type": piece["art_piece_type"],
+                        "place": piece["art_piece_place"],
+                        "emotions": piece["related_emotions"],
+                        "explanation": piece["explanation"],
+                    }
+                    return (
+                        match_image,
+                        f"Prénom '{firstname}' correspond exactement",
+                        match_info,
+                    )
+
+            if birth_date and piece["related_dates"]:
+                date_score = Optimizer.date_similarity(
+                    birth_date, piece["related_dates"]
+                )
+                if date_score == 1.0:
+                    logger.info(
+                        f"🎯 MATCH EXACT TROUVÉ: date '{birthday}' → œuvre #{piece['database_id']}"
+                    )
+                    logger.info(
+                        f"   Dates dans l'œuvre: {[d.strftime('%d/%m/%Y') for d in piece['related_dates']]}"
+                    )
+                    match_image = self._get_artwork_image(piece)
+                    match_info = {
+                        "title": f"Œuvre #{piece['database_id']}",
+                        "type": piece["art_piece_type"],
+                        "place": piece["art_piece_place"],
+                        "emotions": piece["related_emotions"],
+                        "explanation": piece["explanation"],
+                    }
+                    return (
+                        match_image,
+                        f"Date d'anniversaire {birthday} correspond exactement",
+                        match_info,
+                    )
+
+            if city and piece["related_places"]:
+                place_score = self.optimizer_helper.place_similarity(
+                    city, piece["related_places"]
+                )
+                if place_score == 1.0:
+                    logger.info(
+                        f"🎯 MATCH EXACT TROUVÉ: ville '{city}' → œuvre #{piece['database_id']}"
+                    )
+                    logger.info(f"   Lieux dans l'œuvre: {piece['related_places']}")
+                    match_image = self._get_artwork_image(piece)
+                    match_info = {
+                        "title": f"Œuvre #{piece['database_id']}",
+                        "type": piece["art_piece_type"],
+                        "place": piece["art_piece_place"],
+                        "emotions": piece["related_emotions"],
+                        "explanation": piece["explanation"],
+                    }
+                    return (
+                        match_image,
+                        f"Ville '{city}' correspond exactement",
+                        match_info,
+                    )
+
+        logger.info("Aucun match exact trouvé, passage à la sélection par émotions")
+
+        emotion_profile = self.calculate_emotion_profile(selected_image_ids)
+
+        logger.info("=== STRATÉGIE DE MATCHING ===")
+        valid_preselection = preselected[preselected["score"] > (0, 0, 0)]
+
+        if len(valid_preselection) > 0:
+            logger.info(
+                f"📋 CAS A: {len(valid_preselection)} œuvres pré-sélectionnées - utilisation des émotions pour départager"
+            )
+            candidates = valid_preselection
+        else:
+            logger.info(
+                f"📋 CAS B: Aucune pré-sélection valide - recherche par émotions sur {len(self.df_with_images)} œuvres"
+            )
+            candidates = self.df_with_images
+
+        # Exclure les œuvres déjà sélectionnées par l'utilisateur
+        selected_artwork_ids = set(selected_image_ids)
+        candidates = candidates[
+            ~candidates["database_id"].astype(str).isin(selected_artwork_ids)
+        ]
+        logger.info(
+            f"Après exclusion des œuvres déjà sélectionnées {selected_artwork_ids}: {len(candidates)} candidats restants"
+        )
+
+        logger.info("=== CALCUL DES SCORES ÉMOTIONNELS ===")
+        best_matches = []
+        best_emotion_score = -1
+
+        for idx, piece in candidates.iterrows():
+            emotion_score = 0
+
+            if emotion_profile and piece["related_emotions"]:
+                for user_emotion, weight in emotion_profile.items():
+                    best_similarity = 0
+                    for piece_emotion in piece["related_emotions"]:
+                        similarity = self._cached_emotion_similarity(
+                            user_emotion, piece_emotion
+                        )
+                        if similarity > best_similarity:
+                            best_similarity = similarity
+                    emotion_score += best_similarity * weight
+
+                if len(piece["related_emotions"]) > 0:
+                    emotion_score /= len(piece["related_emotions"])
+
+            if emotion_score > best_emotion_score:
+                best_emotion_score = emotion_score
+                best_matches = [piece]
+                logger.info(
+                    f"  Nouveau meilleur score émotionnel: {emotion_score:.3f} - Œuvre #{piece['database_id']}"
+                )
+            elif emotion_score == best_emotion_score and emotion_score > 0:
+                best_matches.append(piece)
+                logger.info(
+                    f"  Score égal au meilleur: {emotion_score:.3f} - Œuvre #{piece['database_id']}"
+                )
+
+        logger.info(
+            f"Nombre de meilleures correspondances: {len(best_matches)} avec score {best_emotion_score:.3f}"
+        )
+
+        if len(best_matches) > 1:
+            logger.info("=== DÉPARTAGE PAR TYPE D'OBJET ===")
+            selected_types = []
+            for img_id in selected_image_ids:
+                if img_id in self.id_to_index:
+                    idx = self.id_to_index[img_id]
+                    selected_types.append(
+                        self.df_with_images.loc[idx, "art_piece_type"]
+                    )
+
+            selected_types_counter = Counter(selected_types)
+
+            type_scored_matches = []
+            best_type_score = -1
+
+            for piece in best_matches:
+                type_score = selected_types_counter.get(piece["art_piece_type"], 0)
+                if type_score > best_type_score:
+                    best_type_score = type_score
+                    type_scored_matches = [piece]
+                elif type_score == best_type_score:
+                    type_scored_matches.append(piece)
+
+            if len(type_scored_matches) > 1:
+                logger.info(
+                    f"  {len(type_scored_matches)} œuvres avec le même score de type ({best_type_score}) - sélection aléatoire"
+                )
+                best_match = random.choice(type_scored_matches)
+                match_reason = (
+                    "Sélection aléatoire parmi les meilleures correspondances"
+                )
+            else:
+                best_match = type_scored_matches[0]
+                match_reason = f"Type d'objet '{best_match['art_piece_type']}' préféré"
+                logger.info(
+                    f"  Type '{best_match['art_piece_type']}' sélectionné avec score {best_type_score}"
+                )
+        elif len(best_matches) == 1:
+            best_match = best_matches[0]
+            match_reason = "Meilleure correspondance émotionnelle"
+        else:
+            logger.info("Aucune correspondance trouvée")
+            return None, "Aucune correspondance trouvée", {}
+
+        reasons = []
+        if len(valid_preselection) > 0:
+            if firstname and best_match["related_names"]:
+                name_score = Optimizer.name_similarity(
+                    firstname, best_match["related_names"]
+                )
+                if name_score > 0:
+                    reasons.append(f"prénom '{firstname}' trouvé")
+
+            if birth_date and best_match["related_dates"]:
+                date_score = Optimizer.date_similarity(
+                    birth_date, best_match["related_dates"]
+                )
+                if date_score > 0:
+                    reasons.append(
+                        f"date {'exacte' if date_score == 1.0 else 'partielle'}"
+                    )
+
+            if city and best_match["related_places"]:
+                place_score = self.optimizer_helper.place_similarity(
+                    city, best_match["related_places"]
+                )
+                if place_score > 0:
+                    reasons.append(f"ville '{city}' trouvée")
+
+        if best_emotion_score > 0:
+            reasons.append(f"correspondance émotionnelle")
+
+        if len(reasons) == 0:
+            reasons.append(match_reason)
+
+        final_reason = " ; ".join(reasons)
+
+        logger.info(f"\n🏆 RÉSULTAT FINAL: Œuvre #{best_match['database_id']}")
+        logger.info(f"   Raison: {final_reason}")
+        logger.info(f"   Type: {best_match['art_piece_type']}")
+        logger.info(f"   Lieu: {best_match['art_piece_place']}")
+
+        match_image = self._get_artwork_image(best_match)
+
+        match_info = {
+            "title": f"Œuvre #{best_match['database_id']}",
+            "type": best_match["art_piece_type"],
+            "place": best_match["art_piece_place"],
+            "emotions": best_match["related_emotions"],
+            "explanation": best_match["explanation"],
+        }
+
+        return match_image, final_reason, match_info
+
+
+csv_path = "PP1-Collection_Database_new-cleaned.csv"
+images_dir = "pictures_data"
+
+if not os.path.exists(csv_path):
+    logger.error(f"Fichier CSV introuvable: {csv_path}")
+if not os.path.exists(images_dir):
+    logger.error(f"Répertoire images introuvable: {images_dir}")
+
+matcher = ArtMatcherV2(csv_path, images_dir)
+
+
+def process_user_info(firstname: str, birthday: str, city: str, state: SessionState):
+    """Traite les informations utilisateur avec validation"""
+    firstname = SecurityValidator.sanitize_input(firstname)
+    city = SecurityValidator.sanitize_input(city)
+
+    state.firstname = firstname
+    state.birthday = birthday
+    state.city = city
+
+    if not firstname or not birthday:
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            "Veuillez remplir au moins votre prénom et date de naissance.",
+            state,
+        )
+
+    is_valid, _ = SecurityValidator.validate_date(birthday)
+    if not is_valid:
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            "Format de date invalide. Utilisez JJ/MM (ex: 15/03)",
+            state,
+        )
+
+    return (
+        gr.update(visible=False),
+        gr.update(visible=True),
+        gr.update(visible=False),
+        "Informations enregistrées ! Passons à la sélection d'images.",
+        state,
+    )
+
+
+def load_images_for_round(round_num: int, state: SessionState):
+    """Charge 3 images pour un tour de sélection"""
+    images_data = matcher.get_random_images_for_selection(
+        round_num, state.selected_images
+    )
+
+    if len(images_data) < ScoringWeights.MAX_IMAGES_PER_SELECTION:
+        logger.warning(f"Seulement {len(images_data)} images disponibles")
+        return (
+            [None, None, None],
+            [],
+            f"Pas assez d'images disponibles (seulement {len(images_data)} trouvées)",
+            state,
+        )
+
+    images = [img[0] for img in images_data]
+    ids = [img[1] for img in images_data]
+
+    state.current_image_ids = ids
+
+    return (
+        images,
+        ids,
+        f"Tour {round_num + 1}/{ScoringWeights.TOTAL_ROUNDS} : Sélectionnez l'image qui vous attire le plus",
+        state,
+    )
+
+
+def select_image(choice: Optional[int], state: SessionState):
+    """Traite la sélection d'image"""
+    if choice is None:
+        return (
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "Veuillez sélectionner une image",
+            state,
+        )
+
+    if state.current_image_ids and len(state.current_image_ids) > choice:
+        selected_id = state.current_image_ids[choice]
+    else:
+        return (
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "Erreur: image non trouvée",
+            state,
+        )
+
+    state.selected_images.append(selected_id)
+    state.current_round += 1
+
+    logger.info(
+        f"Tour {state.current_round}: Image {choice+1} sélectionnée (ID: {selected_id})"
+    )
+
+    if state.current_round < ScoringWeights.TOTAL_ROUNDS:
+        new_images, new_ids, message, state = load_images_for_round(
+            state.current_round, state
+        )
+        return (
+            gr.update(value=new_images[0]),
+            gr.update(value=new_images[1]),
+            gr.update(value=new_images[2]),
+            gr.update(value=None),
+            message,
+            state,
+            gr.update(visible=True),  # keep selection_section visible
+            gr.update(visible=False),  # keep loading_section hidden
+        )
+    else:
+        # Toutes les sélections sont terminées, afficher le loading
+        return (
+            gr.update(),  # img1
+            gr.update(),  # img2
+            gr.update(),  # img3
+            gr.update(),  # image_choice
+            "",  # status_message vide
+            state,
+            gr.update(visible=False),  # hide selection_section
+            gr.update(visible=True),  # show loading_section
+        )
+
+
+def show_results(state: SessionState):
+    """Affiche les résultats finaux"""
+    if not state.is_complete():
+        return (
+            gr.update(visible=False),  # info_section
+            gr.update(visible=True),  # selection_section
+            gr.update(visible=False),  # loading_section
+            gr.update(visible=False),  # results_section
+            None,
+            "",
+            "",
+        )
+
+    match_image, reason, info = matcher.find_best_match(
+        state.firstname,
+        state.birthday,
+        state.city,
+        state.selected_images,
+    )
+
+    if match_image:
+        # Déterminer le type de système de recommandation utilisé
+        if "correspond exactement" in reason.lower():
+            # Match exact sur nom, date ou lieu
+            recommendation_type = "name_date_place"
+        else:
+            # Match basé sur les émotions
+            recommendation_type = "emotions"
+
+        # Enregistrer l'œuvre finale et le type de recommandation
+        state.final_artwork = info.get("title", "Œuvre inconnue")
+        state.recommendation_type = recommendation_type
+
+        # Logger la session
+        session_tracker.log_session(state, recommendation_type)
+
+        explanation = f"""
+**Votre œuvre correspondante a été trouvée !**
+
+**Raison du match :** {reason}
+
+**Détails de l'œuvre :**
+- Type : {info.get('type', 'Non spécifié')}
+- Lieu : {info.get('place', 'Non spécifié')}
+- Émotions : {', '.join(info.get('emotions', [])) if info.get('emotions') else 'Non spécifiées'}
+
+**Description :**
+{info.get('explanation', 'Aucune description disponible')}
+"""
+    else:
+        # Aucune œuvre trouvée - logger quand même
+        state.final_artwork = "Aucune œuvre trouvée"
+        state.recommendation_type = "none"
+        session_tracker.log_session(state, "none")
+
+        explanation = "Désolé, aucune œuvre correspondante n'a pu être trouvée."
+
+    return (
+        gr.update(visible=False),  # info_section
+        gr.update(visible=False),  # selection_section
+        gr.update(visible=False),  # loading_section
+        gr.update(visible=True),  # results_section
+        match_image,
+        info.get("title", "Œuvre non trouvée") if match_image else "Œuvre non trouvée",
+        explanation,
+    )
+
+
+with gr.Blocks(
+    title="Art Matcher",
+    theme=gr.themes.Soft(primary_hue="teal", secondary_hue="teal", neutral_hue="zinc"),
+) as demo:
+    gr.Markdown(
+        """
+        # 🎨 Art Matcher
+        ### Découvrez l'œuvre d'art qui vous correspond !
+        
+        Cette application utilise vos informations personnelles et vos préférences visuelles
+        pour trouver l'œuvre d'art qui vous correspond le mieux dans notre collection.
+        """
+    )
+
+    session_state = gr.State(SessionState())
+
+    with gr.Group(visible=True) as info_section:
+        gr.Markdown("### Étape 1 : Vos informations")
+        with gr.Row():
+            firstname_input = gr.Textbox(
+                label="Prénom", placeholder="Entrez votre prénom", max_lines=1
+            )
+            birthday_input = gr.Textbox(
+                label="Date d'anniversaire (JJ/MM)",
+                placeholder="Ex: 25/12",
+                max_lines=1,
+            )
+            city_input = gr.Textbox(
+                label="Ville de résidence", placeholder="Ex: Paris", max_lines=1
+            )
+
+        submit_info_btn = gr.Button("Valider mes informations", variant="primary")
+
+    with gr.Group(visible=False) as selection_section:
+        selection_title = gr.Markdown("### Étape 2 : Sélection d'images")
+
+        with gr.Row():
+            img1 = gr.Image(label="Image 1", type="filepath", height=300)
+            img2 = gr.Image(label="Image 2", type="filepath", height=300)
+            img3 = gr.Image(label="Image 3", type="filepath", height=300)
+
+        image_choice = gr.Radio(
+            choices=["Image 1", "Image 2", "Image 3"],
+            label="Quelle image vous attire le plus ?",
+            type="index",
+        )
+
+        select_btn = gr.Button("Valider mon choix", variant="primary")
+
+    with gr.Group(visible=False) as loading_section:
+        gr.Markdown("### ⏳ Analyse en cours...")
+        gr.HTML(
+            """
+        <div style="text-align: center; padding: 40px;">
+            <div style="display: inline-block; width: 60px; height: 60px; border: 6px solid #f3f3f3; border-top: 6px solid #14b8a6; border-radius: 50%; animation: spin 1s linear infinite;"></div>
+            <style>
+                @keyframes spin {
+                    0% { transform: rotate(0deg); }
+                    100% { transform: rotate(360deg); }
+                }
+            </style>
+            <p style="margin-top: 20px; font-size: 18px; color: #666;">
+                <strong>Traitement de vos sélections...</strong><br>
+                <span style="font-size: 14px;">Nous analysons votre profil pour trouver l'œuvre parfaite</span>
+            </p>
+        </div>
+        """
+        )
+
+    with gr.Group(visible=False) as results_section:
+        gr.Markdown("### Votre œuvre correspondante")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                result_image = gr.Image(label="Votre œuvre", height=400)
+                result_title = gr.Markdown("## Titre de l'œuvre")
+
+            with gr.Column(scale=1):
+                result_explanation = gr.Markdown("")
+
+        restart_btn = gr.Button("Recommencer", variant="secondary")
+
+    status_message = gr.Markdown("")
+
+    def on_info_submit(firstname, birthday, city, state):
+        state.reset()
+
+        info_vis, select_vis, results_vis, message, state = process_user_info(
+            firstname, birthday, city, state
+        )
+
+        if select_vis["visible"]:
+            images, ids, round_message, state = load_images_for_round(0, state)
+            return (
+                info_vis,
+                select_vis,
+                results_vis,
+                images[0] if len(images) > 0 else None,
+                images[1] if len(images) > 1 else None,
+                images[2] if len(images) > 2 else None,
+                round_message,
+                state,
+            )
+        else:
+            return (info_vis, select_vis, results_vis, None, None, None, message, state)
+
+    submit_info_btn.click(
+        fn=on_info_submit,
+        inputs=[firstname_input, birthday_input, city_input, session_state],
+        outputs=[
+            info_section,
+            selection_section,
+            results_section,
+            img1,
+            img2,
+            img3,
+            status_message,
+            session_state,
+        ],
+    )
+
+    def on_image_select(choice, state):
+        result = select_image(choice, state)
+
+        # La fonction select_image retourne maintenant 8 valeurs
+        if len(result) == 8:
+            (
+                img1_update,
+                img2_update,
+                img3_update,
+                choice_update,
+                message,
+                state,
+                selection_vis,
+                loading_vis,
+            ) = result
+            return (
+                gr.update(),  # info_section
+                selection_vis,  # selection_section
+                loading_vis,  # loading_section
+                gr.update(),  # results_section
+                img1_update,  # img1
+                img2_update,  # img2
+                img3_update,  # img3
+                choice_update,  # image_choice
+                message,  # status_message
+                state,
+            )
+        else:
+            # Format avec 6 valeurs (cas sans loading)
+            (img1_update, img2_update, img3_update, choice_update, message, state) = (
+                result
+            )
+            return (
+                gr.update(),  # info_section
+                gr.update(),  # selection_section
+                gr.update(),  # loading_section
+                gr.update(),  # results_section
+                img1_update,  # img1
+                img2_update,  # img2
+                img3_update,  # img3
+                choice_update,  # image_choice
+                message,  # status_message
+                state,
+            )
+
+    def handle_final_results(state):
+        if state.is_complete():
+            return show_results(state)
+        else:
+            return gr.update(), gr.update(), gr.update(), gr.update(), None, "", ""
+
+    select_btn.click(
+        fn=on_image_select,
+        inputs=[image_choice, session_state],
+        outputs=[
+            info_section,
+            selection_section,
+            loading_section,
+            results_section,
+            img1,
+            img2,
+            img3,
+            image_choice,
+            status_message,
+            session_state,
+        ],
+    ).then(
+        fn=handle_final_results,
+        inputs=[session_state],
+        outputs=[
+            info_section,
+            selection_section,
+            loading_section,
+            results_section,
+            result_image,
+            result_title,
+            result_explanation,
+        ],
+    )
+
+    def restart_app(state):
+        state.reset()
+
+        return (
+            gr.update(visible=True),  # info_section
+            gr.update(visible=False),  # selection_section
+            gr.update(visible=False),  # loading_section
+            gr.update(visible=False),  # results_section
+            "",  # firstname_input
+            "",  # birthday_input
+            "",  # city_input
+            None,  # image_choice
+            "Application réinitialisée. Veuillez entrer vos informations.",  # status_message
+            state,
+        )
+
+    restart_btn.click(
+        fn=restart_app,
+        inputs=[session_state],
+        outputs=[
+            info_section,
+            selection_section,
+            loading_section,
+            results_section,
+            firstname_input,
+            birthday_input,
+            city_input,
+            image_choice,
+            status_message,
+            session_state,
+        ],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()