Update app.py

app.py

@@ -5,6 +5,11 @@ from flask import Flask, request, jsonify, make_response
 
 from presidio_analyzer import AnalyzerEngine, RecognizerRegistry, PatternRecognizer, Pattern
 from presidio_analyzer.nlp_engine import NlpEngineProvider
+# On importe les recognizers prédéfinis qu'on veut pouvoir utiliser
+from presidio_analyzer.predefined_recognizers import (
+    CreditCardRecognizer, CryptoRecognizer, DateRecognizer, IpRecognizer,
+    MedicalLicenseRecognizer, UrlRecognizer, SpacyRecognizer
+)
 
 # Configuration du logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -13,6 +18,19 @@ logger = logging.getLogger(__name__)
 # Initialisation de l'application Flask
 app = Flask(__name__)
 
+# --- Dictionnaire pour mapper les noms du YAML aux classes Python ---
+# C'est ce qui nous permet de lire la liste 'recognizer_registry' du YAML
+PREDEFINED_RECOGNIZERS_MAP = {
+    "SpacyRecognizer": SpacyRecognizer,
+    "CreditCardRecognizer": CreditCardRecognizer,
+    "CryptoRecognizer": CryptoRecognizer,
+    "DateRecognizer": DateRecognizer,
+    "IpRecognizer": IpRecognizer,
+    "MedicalLicenseRecognizer": MedicalLicenseRecognizer,
+    "UrlRecognizer": UrlRecognizer,
+}
+
+
 # --- Initialisation Globale de l'Analyseur ---
 analyzer = None
 try:
@@ -25,20 +43,30 @@ try:
         config = yaml.safe_load(f)
     logger.info("Configuration file loaded successfully.")
 
-    # 2. Créer le fournisseur de moteur NLP avec TOUTE la configuration
+    # 2. Créer le fournisseur de moteur NLP
     logger.info("Creating NLP engine provider...")
     provider = NlpEngineProvider(nlp_configuration=config)
     
-    # 3. Créer le registre de recognizers
-    logger.info("Creating and populating recognizer registry...")
+    # 3. Créer le registre de recognizers EN SUIVANT LE YAML
+    logger.info("Creating and populating recognizer registry from config file...")
     registry = RecognizerRegistry()
-    # On charge les recognizers par défaut pour les langues supportées
-    registry.load_predefined_recognizers(languages=config.get("supported_languages"))
-    
-    # 4. Charger les recognizers personnalisés depuis la configuration
+
+    # === DÉBUT DE LA CORRECTION MAJEURE ===
+
+    # A) Charger les recognizers PRÉDÉFINIS listés dans le YAML
+    supported_languages = config.get("supported_languages", ["en"])
+    for recognizer_name in config.get("recognizer_registry", []):
+        if recognizer_name in PREDEFINED_RECOGNIZERS_MAP:
+            recognizer_class = PREDEFINED_RECOGNIZERS_MAP[recognizer_name]
+            # On passe les langues supportées à chaque recognizer qu'on instancie
+            registry.add_recognizer(recognizer_class(supported_languages=supported_languages))
+            logger.info(f"Loaded predefined recognizer: {recognizer_name}")
+
+    # B) Charger les recognizers PERSONNALISÉS définis dans le YAML
     custom_recognizers_conf = config.get("recognizers", [])
     for recognizer_conf in custom_recognizers_conf:
         patterns = [Pattern(name=p['name'], regex=p['regex'], score=p['score']) for p in recognizer_conf['patterns']]
+        # On s'assure de ne pas recréer un recognizer prédéfini mais bien un custom
         custom_recognizer = PatternRecognizer(
             supported_entity=recognizer_conf['entity_name'],
             name=recognizer_conf['name'],
@@ -47,20 +75,25 @@ try:
             context=recognizer_conf.get('context')
         )
         registry.add_recognizer(custom_recognizer)
-        logger.info(f"Loaded custom recognizer: {custom_recognizer.name}")
+        logger.info(f"Loaded custom recognizer from YAML: {custom_recognizer.name}")
 
-    # 5. Créer l'AnalyzerEngine avec tous les composants
+    # === FIN DE LA CORRECTION MAJEURE ===
+
+    # 4. Créer l'AnalyzerEngine avec tous les composants
     logger.info("Initializing AnalyzerEngine with custom components...")
     analyzer = AnalyzerEngine(
         nlp_engine=provider.create_engine(),
         registry=registry,
-        supported_languages=config.get("supported_languages")
+        supported_languages=supported_languages
     )
+    # L'allow list est chargée automatiquement par l'AnalyzerEngine
+    analyzer.set_allow_list(config.get("allow_list", []))
+
     logger.info("--- Presidio Analyzer Service Ready ---")
 
 except Exception as e:
     logger.exception("FATAL: Error during AnalyzerEngine initialization.")
-    analyzer = None # S'assurer que l'analyzer est None en cas d'échec
+    analyzer = None 
 
 @app.route('/analyze', methods=['POST'])
 def analyze_text():
@@ -70,13 +103,13 @@ def analyze_text():
     try:
         data = request.get_json(force=True)
         text_to_analyze = data.get("text", "")
-        language = data.get("language", "fr") # Mettre 'fr' par défaut
+        # Utiliser la première langue supportée comme langue par défaut si non fournie
+        default_lang = analyzer.supported_languages[0] if analyzer.supported_languages else "en"
+        language = data.get("language", default_lang)
 
         if not text_to_analyze:
              return jsonify({"error": "text field is missing or empty"}), 400
         
-        # L'allow list est chargée directement depuis la configuration de l'Analyzer
-        # car c'est une fonctionnalité intégrée.
         results = analyzer.analyze(
             text=text_to_analyze,
             language=language
@@ -86,7 +119,6 @@ def analyze_text():
         return make_response(jsonify(response_data), 200)
     except Exception as e:
         logger.exception(f"Error during analysis request for language '{language}'.")
-        # Renvoyer l'erreur spécifique de Presidio si elle est informative
         if "No matching recognizers" in str(e):
              return jsonify({"error": f"No recognizers available for language '{language}'. Please ensure the language model and recognizers are configured."}), 400
         return jsonify({"error": str(e)}), 500