Spaces:
Sleeping
Sleeping
| import re | |
| import logging | |
| from typing import Dict, List, Optional, Tuple, Any | |
| from dataclasses import dataclass | |
| from enum import Enum | |
| logger = logging.getLogger(__name__) | |
| class FieldType(Enum): | |
| """Types de champs dans le template""" | |
| CHECKBOX = "checkbox" # &x cases à cocher | |
| TEXT = "text" # &x texte libre | |
| MEASUREMENT = "measurement" # &x valeurs numériques | |
| class TemplateField: | |
| """Définition d'un champ du template""" | |
| placeholder: str # &x dans le template | |
| field_type: FieldType | |
| source_field: str # Champ correspondant dans ExtractedData | |
| default_value: str = "" | |
| validation_pattern: Optional[str] = None | |
| transformation_func: Optional[callable] = None | |
| context_identifier: Optional[str] = None # Pour différencier gauche/droite | |
| class MappingResult: | |
| """Résultat du mapping""" | |
| filled_template: str | |
| mapped_fields: Dict[str, str] | |
| unmapped_placeholders: List[str] | |
| mapping_confidence: float | |
| errors: List[str] | |
| class MedicalTemplateMapper: | |
| """Moteur de mapping des données extraites vers le template médical""" | |
| def __init__(self): | |
| self.template = self._load_template() | |
| self.field_mappings = self._define_field_mappings() | |
| self.checkbox_logic = self._define_checkbox_logic() | |
| def _load_template(self) -> str: | |
| """Template médical de base avec placeholders &x""" | |
| return """L'utérus est &x antéversé, &x rétroversé, &x intermédiaire, &x rétrofléchi, &x antéfléchi, &x fixe de taille normale (&x x &x x &x cm). | |
| Hystérométrie : distance orifice externe du col - fond de la cavité utérine : &x mm. | |
| L'endomètre : mesuré à &x mm. | |
| Myometre : pas de myome. | |
| Zone jonctionnelle : Atteinte de la zone de jonction : &x non &x oui | |
| Adénomyose associée : &x non &x oui : &x diffuse &x focale &x interne &x externe | |
| Col utérin: pas de kyste de Naboth. Absence de pathologies échographiquement décelable à son niveau. | |
| Cavité utérine en 3D: morphologie triangulaire. | |
| &xKISSING OVARIES | |
| L'ovaire droit mesure &x x &x mm, &x est de dimensions supérieures à la normale il mesure &x x &x mm, &x folliculaire CFA &x follicules: (&x mm). &x Absence d'endométriome. &x Présence d'une formation kystique hypoéchogène, uniloculaire, non vascularisé, à contenu ground glass mesurée à &x mm d'allure endométriome. | |
| Accessibilité : &x rétro-utérin &x fixe &x aisée. | |
| L'ovaire gauche mesure &x x &x mm, &x est de dimensions supérieures à la normale il mesure &x x &x mm, &x folliculaire CFA &x follicules: (&x mm). &x Absence d'endométriome. &x Présence d'une formation kystique hypoéchogène, uniloculaire, non vascularisé, à contenu ground glass mesurée à &x mm d'allure endométriome. | |
| Accessibilité : &x rétro-utérin &x fixe &x aisée. | |
| &x Présence de micro-calcifications sous thécales &x bilatérales &x droites &x gauches pouvant témoigner d'implants endométriosiques superficiels. | |
| L'échostructure des deux ovaires apparait normale, avec une vascularisation artério-veineuse normale au Doppler, sans formation ou image kystique pathologique échographiquement décelable à leur niveau. | |
| Cavité péritonéale | |
| &x- Pas d'épanchement liquidien dans le cul du sac du Douglas. Pas de douleur à l'écho-palpation. | |
| &x- Faible épanchement corpusculé dans le cul du sac du Douglas qui silhouette des adhérences (soft marqueur d'endométriose?). Pas de douleur à l'écho-palpation. | |
| - &xVessie vide pendant l'examen. &x Vessie en semi-réplétion pendant l'examen. | |
| - &x Absence de dilatation pyélo-calicielle. | |
| - Artère utérine : IP : &x - IR : 0,&x - Spectre : type 2 avec notch protodiastolique. | |
| - Pas d'image d'hydrosalpinx visible à ce jour. | |
| RECHERCHE ENDOMETRIOSE PELVIENNE | |
| A-Compartiment antérieur (vessie en semi-réplétion) | |
| - Signe du glissement (sliding) : &xprésent &xdiminué &xabsent | |
| - Présence d'un nodule : &xnon &xoui | |
| - Uretères dans la partie pelvienne vus non dilatés. | |
| B-Compartiment postérieur | |
| - Signe du glissement (sliding) : | |
| - Espace recto-vaginal : &xprésent &xdiminué &xabsent | |
| - Plan sus-péritonéal : &xprésent &xdiminué &xabsent | |
| - Aspect du torus : &x normal &x épaissi | |
| - Aspect des ligaments utéro-sacrés : | |
| - Ligament utéro- sacré droit : &x normal &x épaissi | |
| - Ligament utéro-sacré gauche : &x normal &x épaissi | |
| - Présence d'un nodule hypoéchogène : &x non | |
| - Infiltration digestive: &x non &x oui : &x bas rectum &x moyen rectum &x haut rectum &x jonction recto-sigmoïde | |
| Conclusions | |
| Utérus de taille et de morphologie normales. | |
| Endomètre mesuré à &x mm. | |
| CFA : &x+&x follicules. | |
| Ovaires sans formation ou image kystique pathologique échographiquement décelable à leur niveau. | |
| &x Absence d'image d'endométriose visible ce jour, à confronter éventuellement à une IRM. | |
| &x Endométriose &x superficielle &x et profonde. | |
| Absence d'anomalie échographiquement décelable au niveau des trompes. | |
| --> L'ensemble de ces aspects reste à confronter au contexte clinico-thérapeutique. | |
| (qui contient des trous représentés par &x)""" | |
| def _define_field_mappings(self) -> Dict[str, TemplateField]: | |
| """Définit les mappings entre données extraites et placeholders template""" | |
| return { | |
| # Position utérus - checkboxes | |
| "uterus_position_antéversé": TemplateField( | |
| placeholder="&x antéversé", | |
| field_type=FieldType.CHECKBOX, | |
| source_field="uterus_position", | |
| transformation_func=lambda x: "X" if x and "antéversé" in x.lower() else "" | |
| ), | |
| "uterus_position_rétroversé": TemplateField( | |
| placeholder="&x rétroversé", | |
| field_type=FieldType.CHECKBOX, | |
| source_field="uterus_position", | |
| transformation_func=lambda x: "X" if x and "rétroversé" in x.lower() else "" | |
| ), | |
| # Taille utérus - dimensions | |
| "uterus_size_length": TemplateField( | |
| placeholder="normale (&x x", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="uterus_size", | |
| transformation_func=self._extract_first_dimension | |
| ), | |
| "uterus_size_width": TemplateField( | |
| placeholder="x &x x", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="uterus_size", | |
| transformation_func=self._extract_second_dimension | |
| ), | |
| "uterus_size_height": TemplateField( | |
| placeholder="x &x cm)", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="uterus_size", | |
| transformation_func=self._extract_third_dimension | |
| ), | |
| # Hystérométrie | |
| "hysterometry_value": TemplateField( | |
| placeholder="fond de la cavité utérine : &x mm", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="hysterometry", | |
| transformation_func=self._clean_numeric_value | |
| ), | |
| # Endomètre | |
| "endometrium_thickness": TemplateField( | |
| placeholder="L'endomètre : mesuré à &x mm", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="endometrium_thickness", | |
| transformation_func=self._clean_numeric_value | |
| ), | |
| # Zone jonctionnelle | |
| "junctional_zone_non": TemplateField( | |
| placeholder="Atteinte de la zone de jonction : &x non", | |
| field_type=FieldType.CHECKBOX, | |
| source_field="junctional_zone_status", | |
| transformation_func=lambda x: "X" if not x or x.lower() in ["normale", "normal"] else "" | |
| ), | |
| "junctional_zone_oui": TemplateField( | |
| placeholder="&x oui", | |
| field_type=FieldType.CHECKBOX, | |
| source_field="junctional_zone_status", | |
| transformation_func=lambda x: "X" if x and x.lower() in ["épaissie", "épaisse", "atteinte"] else "" | |
| ), | |
| # Adénomyose | |
| "adenomyosis_non": TemplateField( | |
| placeholder="Adénomyose associée : &x non", | |
| field_type=FieldType.CHECKBOX, | |
| source_field="adenomyosis_type", | |
| transformation_func=lambda x: "X" if not x or x.lower() in ["absente", "non"] else "" | |
| ), | |
| "adenomyosis_oui": TemplateField( | |
| placeholder="&x oui :", | |
| field_type=FieldType.CHECKBOX, | |
| source_field="adenomyosis_type", | |
| transformation_func=lambda x: "X" if x and x.lower() in ["diffuse", "focale"] else "" | |
| ), | |
| "adenomyosis_diffuse": TemplateField( | |
| placeholder="&x diffuse", | |
| field_type=FieldType.CHECKBOX, | |
| source_field="adenomyosis_type", | |
| transformation_func=lambda x: "X" if x and "diffuse" in x.lower() else "" | |
| ), | |
| # Doppler | |
| "doppler_ip": TemplateField( | |
| placeholder="IP : &x", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="doppler_ip", | |
| transformation_func=self._clean_numeric_value | |
| ), | |
| "doppler_ir": TemplateField( | |
| placeholder="IR : 0,&x", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="doppler_ir", | |
| transformation_func=self._format_doppler_ir | |
| ), | |
| # Conclusion - endomètre | |
| "conclusion_endometrium": TemplateField( | |
| placeholder="Endomètre mesuré à &x mm", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="endometrium_thickness", | |
| transformation_func=self._clean_numeric_value | |
| ), | |
| # Conclusions - CFA total | |
| "conclusion_cfa_right": TemplateField( | |
| placeholder="CFA : &x+", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="right_ovary_cfa", | |
| transformation_func=self._clean_cfa_value | |
| ), | |
| "conclusion_cfa_left": TemplateField( | |
| placeholder="+&x follicules", | |
| field_type=FieldType.MEASUREMENT, | |
| source_field="left_ovary_cfa", | |
| transformation_func=self._clean_cfa_value | |
| ), | |
| } | |
| def _define_checkbox_logic(self) -> Dict[str, List[str]]: | |
| """Définit la logique des checkboxes mutuellement exclusives""" | |
| return { | |
| "uterus_position": ["antéversé", "rétroversé", "intermédiaire", "rétrofléchi", "antéfléchi"], | |
| "adenomyosis": ["non", "oui"], | |
| "adenomyosis_type": ["diffuse", "focale", "interne", "externe"], | |
| "ovary_accessibility": ["rétro-utérin", "fixe", "aisée"] | |
| } | |
| def map_extracted_data_to_template(self, extracted_data) -> MappingResult: | |
| """ | |
| Fonction principale de mapping des données extraites vers le template | |
| """ | |
| logger.info("🔄 Début du mapping vers le template médical") | |
| filled_template = self.template | |
| mapped_fields = {} | |
| unmapped_placeholders = [] | |
| errors = [] | |
| # Étape 1: Identifier tous les placeholders &x dans le template | |
| all_placeholders = self._find_all_placeholders(filled_template) | |
| logger.info(f"📍 {len(all_placeholders)} placeholders trouvés dans le template") | |
| # Étape 2: Appliquer les mappings définis | |
| for mapping_key, template_field in self.field_mappings.items(): | |
| try: | |
| # Récupérer la valeur source | |
| source_value = getattr(extracted_data, template_field.source_field, None) | |
| if source_value: | |
| # Appliquer la transformation | |
| if template_field.transformation_func: | |
| mapped_value = template_field.transformation_func(source_value) | |
| else: | |
| mapped_value = str(source_value) | |
| # Remplacer dans le template | |
| if mapped_value and mapped_value.strip(): | |
| filled_template = self._replace_placeholder_in_context( | |
| filled_template, template_field.placeholder, mapped_value | |
| ) | |
| mapped_fields[mapping_key] = mapped_value | |
| logger.debug(f"✅ {mapping_key}: {mapped_value}") | |
| except Exception as e: | |
| error_msg = f"Erreur mapping {mapping_key}: {e}" | |
| errors.append(error_msg) | |
| logger.error(error_msg) | |
| # Étape 3: Traitement spécial pour les ovaires | |
| filled_template = self._handle_ovary_section(filled_template, extracted_data) | |
| # Étape 4: Application des règles de logique métier | |
| filled_template = self._apply_business_logic(filled_template, extracted_data) | |
| # Étape 5: Gestion des placeholders non mappés | |
| remaining_placeholders = self._find_all_placeholders(filled_template) | |
| unmapped_placeholders = [p for p in remaining_placeholders if "&x" in p] | |
| # Étape 6: Calcul du score de mapping | |
| mapping_confidence = self._calculate_mapping_confidence( | |
| len(mapped_fields), len(all_placeholders), len(errors) | |
| ) | |
| logger.info(f"✅ Mapping terminé - {len(mapped_fields)} champs mappés, {len(unmapped_placeholders)} non mappés") | |
| return MappingResult( | |
| filled_template=filled_template, | |
| mapped_fields=mapped_fields, | |
| unmapped_placeholders=unmapped_placeholders, | |
| mapping_confidence=mapping_confidence, | |
| errors=errors | |
| ) | |
| def _handle_ovary_section(self, template: str, extracted_data) -> str: | |
| """Traite spécifiquement la section des ovaires""" | |
| # Traitement ovaire droit | |
| if hasattr(extracted_data, 'right_ovary_dimensions') and extracted_data.right_ovary_dimensions: | |
| dimensions = self._parse_dimensions(extracted_data.right_ovary_dimensions) | |
| if len(dimensions) >= 2: | |
| # Remplacer les dimensions de l'ovaire droit | |
| template = self._replace_ovary_dimensions(template, "droit", dimensions[0], dimensions[1]) | |
| # CFA ovaire droit | |
| if hasattr(extracted_data, 'right_ovary_cfa') and extracted_data.right_ovary_cfa: | |
| cfa_value = self._clean_cfa_value(extracted_data.right_ovary_cfa) | |
| template = self._replace_ovary_cfa(template, "droit", cfa_value) | |
| # Accessibilité ovaire droit | |
| if hasattr(extracted_data, 'right_ovary_accessibility') and extracted_data.right_ovary_accessibility: | |
| template = self._replace_ovary_accessibility(template, "droit", extracted_data.right_ovary_accessibility) | |
| # Traitement ovaire gauche | |
| if hasattr(extracted_data, 'left_ovary_dimensions') and extracted_data.left_ovary_dimensions: | |
| dimensions = self._parse_dimensions(extracted_data.left_ovary_dimensions) | |
| if len(dimensions) >= 2: | |
| # Remplacer les dimensions de l'ovaire gauche | |
| template = self._replace_ovary_dimensions(template, "gauche", dimensions[0], dimensions[1]) | |
| # CFA ovaire gauche | |
| if hasattr(extracted_data, 'left_ovary_cfa') and extracted_data.left_ovary_cfa: | |
| cfa_value = self._clean_cfa_value(extracted_data.left_ovary_cfa) | |
| template = self._replace_ovary_cfa(template, "gauche", cfa_value) | |
| # Accessibilité ovaire gauche | |
| if hasattr(extracted_data, 'left_ovary_accessibility') and extracted_data.left_ovary_accessibility: | |
| template = self._replace_ovary_accessibility(template, "gauche", extracted_data.left_ovary_accessibility) | |
| return template | |
| def _replace_ovary_dimensions(self, template: str, side: str, dim1: str, dim2: str) -> str: | |
| """Remplace les dimensions d'un ovaire spécifique""" | |
| lines = template.split('\n') | |
| for i, line in enumerate(lines): | |
| if f"ovaire {side} mesure" in line.lower(): | |
| # Remplacer les deux premiers &x pour les dimensions principales | |
| if "&x x &x mm" in line: | |
| line = line.replace("&x x &x mm", f"{dim1} x {dim2} mm", 1) | |
| lines[i] = line | |
| break | |
| return '\n'.join(lines) | |
| def _replace_ovary_cfa(self, template: str, side: str, cfa_value: str) -> str: | |
| """Remplace la valeur CFA d'un ovaire spécifique""" | |
| lines = template.split('\n') | |
| for i, line in enumerate(lines): | |
| if f"ovaire {side}" in line.lower() and i < len(lines) - 1: | |
| # Chercher la ligne avec CFA dans les lignes suivantes | |
| for j in range(i, min(i+3, len(lines))): | |
| if "folliculaire CFA &x follicules" in lines[j]: | |
| lines[j] = lines[j].replace("&x folliculaire CFA &x follicules", f"{cfa_value} folliculaire CFA") | |
| break | |
| break | |
| return '\n'.join(lines) | |
| def _replace_ovary_accessibility(self, template: str, side: str, accessibility: str) -> str: | |
| """Remplace l'accessibilité d'un ovaire spécifique""" | |
| lines = template.split('\n') | |
| in_ovary_section = False | |
| for i, line in enumerate(lines): | |
| if f"ovaire {side}" in line.lower(): | |
| in_ovary_section = True | |
| elif in_ovary_section and "Accessibilité" in line: | |
| # Déterminer quelle case cocher | |
| if "rétro" in accessibility.lower(): | |
| line = line.replace("Accessibilité : &x rétro-utérin", "Accessibilité : X rétro-utérin") | |
| elif "fixe" in accessibility.lower(): | |
| line = line.replace("&x fixe", "X fixe") | |
| else: # normale ou aisée | |
| line = line.replace("&x aisée", "X aisée") | |
| lines[i] = line | |
| in_ovary_section = False | |
| break | |
| return '\n'.join(lines) | |
| def _parse_dimensions(self, dimensions_str: str) -> List[str]: | |
| """Parse les dimensions à partir d'une chaîne""" | |
| if not dimensions_str: | |
| return [] | |
| # Extraire tous les nombres | |
| matches = re.findall(r'(\d+(?:[.,]\d+)?)', dimensions_str) | |
| return [match.replace(',', '.') for match in matches] | |
| def _find_all_placeholders(self, template: str) -> List[str]: | |
| """Trouve tous les placeholders &x dans le template""" | |
| pattern = r'[^.]*&x[^.]*' | |
| matches = re.findall(pattern, template) | |
| return matches | |
| def _replace_placeholder_in_context(self, template: str, context_pattern: str, value: str) -> str: | |
| """Remplace &x dans un contexte spécifique""" | |
| escaped_pattern = re.escape(context_pattern).replace(r'\&x', r'&x') | |
| def replace_func(match): | |
| return match.group(0).replace('&x', value, 1) | |
| return re.sub(escaped_pattern, replace_func, template) | |
| def _apply_business_logic(self, template: str, extracted_data) -> str: | |
| """Applique la logique métier spécifique au domaine médical""" | |
| # Logique par défaut pour les examens standard | |
| template = template.replace("- &xVessie vide pendant l'examen", "- XVessie vide pendant l'examen") | |
| template = template.replace("&x Absence de dilatation pyélo-calicielle", "X Absence de dilatation pyélo-calicielle") | |
| template = template.replace("&x Absence d'image d'endométriose visible ce jour", "X Absence d'image d'endométriose visible ce jour") | |
| return template | |
| def _calculate_mapping_confidence(self, mapped_count: int, total_placeholders: int, error_count: int) -> float: | |
| """Calcule le score de confiance du mapping""" | |
| if total_placeholders == 0: | |
| return 1.0 | |
| base_confidence = mapped_count / total_placeholders | |
| error_penalty = min(error_count * 0.1, 0.3) | |
| return max(0.0, base_confidence - error_penalty) | |
| # Fonctions de transformation des données | |
| def _clean_numeric_value(self, value: str) -> str: | |
| """Nettoie les valeurs numériques""" | |
| if not value: | |
| return "" | |
| cleaned = re.sub(r'\s*(mm|cm)\s*(mm|cm)', r' \1', str(value)) | |
| cleaned = re.sub(r'\s*(mm|cm).*', r'', cleaned) | |
| cleaned = cleaned.replace(',', '.').strip() | |
| return cleaned | |
| def _clean_cfa_value(self, value: str) -> str: | |
| """Nettoie les valeurs CFA""" | |
| if not value: | |
| return "" | |
| cleaned = str(value).replace(' follicules', '').replace(' follicules follicules', '').strip() | |
| match = re.search(r'(\d+)', cleaned) | |
| return match.group(1) if match else cleaned | |
| def _extract_first_dimension(self, dimensions: str) -> str: | |
| """Extrait la première dimension""" | |
| if not dimensions: | |
| return "" | |
| match = re.search(r'(\d+(?:[.,]\d+)?)', dimensions) | |
| return match.group(1).replace(',', '.') if match else "" | |
| def _extract_second_dimension(self, dimensions: str) -> str: | |
| """Extrait la deuxième dimension""" | |
| if not dimensions: | |
| return "" | |
| matches = re.findall(r'(\d+(?:[.,]\d+)?)', dimensions) | |
| return matches[1].replace(',', '.') if len(matches) > 1 else "" | |
| def _extract_third_dimension(self, dimensions: str) -> str: | |
| """Extrait la troisième dimension""" | |
| if not dimensions: | |
| return "" | |
| matches = re.findall(r'(\d+(?:[.,]\d+)?)', dimensions) | |
| return matches[2].replace(',', '.') if len(matches) > 2 else "" | |
| def _format_doppler_ir(self, ir_value: str) -> str: | |
| """Formate la valeur IR pour le template""" | |
| if not ir_value: | |
| return "" | |
| cleaned = self._clean_numeric_value(ir_value) | |
| if cleaned.startswith('0.'): | |
| return cleaned[2:] | |
| elif '.' in cleaned: | |
| return cleaned.split('.')[1] | |
| return cleaned | |
| def print_mapping_report(self, result: MappingResult) -> str: | |
| """Génère un rapport de mapping formaté""" | |
| report = "🔄 RAPPORT DE MAPPING TEMPLATE\n" | |
| report += "=" * 50 + "\n\n" | |
| report += f"📊 STATISTIQUES:\n" | |
| report += f" Champs mappés: {len(result.mapped_fields)}\n" | |
| report += f" Placeholders non mappés: {len(result.unmapped_placeholders)}\n" | |
| report += f" Score de confiance: {result.mapping_confidence:.1%}\n" | |
| report += f" Erreurs: {len(result.errors)}\n\n" | |
| if result.mapped_fields: | |
| report += "✅ CHAMPS MAPPÉS:\n" | |
| for field, value in result.mapped_fields.items(): | |
| report += f" {field}: {value}\n" | |
| report += "\n" | |
| if result.unmapped_placeholders: | |
| report += "❌ PLACEHOLDERS NON MAPPÉS:\n" | |
| for placeholder in result.unmapped_placeholders[:10]: | |
| report += f" {placeholder[:50]}...\n" | |
| if len(result.unmapped_placeholders) > 10: | |
| report += f" ... et {len(result.unmapped_placeholders) - 10} autres\n" | |
| report += "\n" | |
| if result.errors: | |
| report += "⚠️ ERREURS:\n" | |
| for error in result.errors: | |
| report += f" {error}\n" | |
| return report | |
| # Classe exemple pour les données extraites avec vos données | |
| class ExtractedData: | |
| """Classe exemple pour les données extraites""" | |
| def __init__(self): | |
| self.uterus_position = "antéversé" | |
| self.uterus_size = "7,8 cm" | |
| self.hysterometry = "60 mm" | |
| self.endometrium_thickness = "3,7 mm" | |
| self.junctional_zone_status = "épaissie" | |
| self.adenomyosis_type = "diffuse" | |
| # Données ovaires avec vos valeurs exactes | |
| self.right_ovary_dimensions = "26 x 20 mm" | |
| self.right_ovary_cfa = "5 follicules" | |
| self.right_ovary_accessibility = "normale" | |
| self.left_ovary_dimensions = "25 x 19 mm" | |
| self.left_ovary_cfa = "22 follicules" | |
| self.left_ovary_accessibility = "difficile rétro-utérine" | |
| # Données Doppler | |
| self.doppler_ip = "3,24" | |
| self.doppler_ir = "0,91" | |
| def test_corrected_ovary_mapping(): | |
| """Test du mapping corrigé des ovaires""" | |
| data = ExtractedData() | |
| mapper = MedicalTemplateMapper() | |
| result = mapper.map_extracted_data_to_template(data) | |
| print("🔧 TEST DU MAPPING OVAIRES CORRIGÉ") | |
| print("=" * 40) | |
| print(mapper.print_mapping_report(result)) | |
| print("\n🔍 SECTION OVAIRES DANS LE RÉSULTAT:") | |
| print("-" * 40) | |
| # Extraire et afficher la section ovaires | |
| lines = result.filled_template.split('\n') | |
| ovary_section = [] | |
| in_ovary_section = False | |
| for line in lines: | |
| if "KISSING OVARIES" in line: | |
| in_ovary_section = True | |
| elif in_ovary_section and line.strip() == "": | |
| if ovary_section: # Si on a déjà collecté des lignes | |
| break | |
| if in_ovary_section: | |
| ovary_section.append(line) | |
| if "L'échostructure des deux ovaires" in line: | |
| break | |
| print('\n'.join(ovary_section)) | |
| return result.filled_template | |
| if __name__ == "__main__": | |
| filled_report = test_corrected_ovary_mapping() |