From 37f3b9529811dc69e4008017ec4e69d1d7970d6d Mon Sep 17 00:00:00 2001 From: Nacim Date: Mon, 23 Jun 2025 16:16:53 +0200 Subject: [PATCH] Update app.py --- app.py | 62 ++++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 47 insertions(+), 15 deletions(-) diff --git a/app.py b/app.py index f0faeee..d6384f4 100644 --- a/app.py +++ b/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