Upload app.py

app.py

@@ -211,7 +211,62 @@ def extract_entities(textos: List[str]) -> List[List[Tuple[str, str]]]:
                    if len(ent.text.strip()) > 2 and ent.label_ in ("PERSON", "PER", "ORG", "GPE", "LOC")]
         entities_by_doc.append(entities)
     
-    return entities_by_doc
+    # Normalizar entidades para deduplicação
+    return normalize_entities(entities_by_doc)
+
+def normalize_entities(entities_by_doc: List[List[Tuple[str, str]]]) -> List[List[Tuple[str, str]]]:
+    """Normaliza entidades para agrupar variações do mesmo nome."""
+    
+    # Coletar todas as entidades únicas por tipo
+    all_entities = defaultdict(set)
+    for entities in entities_by_doc:
+        for text, etype in entities:
+            all_entities[etype].add(text)
+    
+    # Criar mapeamento de normalização
+    # Agrupa entidades onde uma contém a outra ou são muito similares
+    normalization_map = {}
+    
+    for etype, entity_set in all_entities.items():
+        entities_list = sorted(entity_set, key=len, reverse=True)  # Maiores primeiro
+        
+        for entity in entities_list:
+            if entity in normalization_map:
+                continue
+            
+            # Encontrar entidades que são parte desta ou similares
+            canonical = entity
+            for other in entities_list:
+                if other == entity:
+                    continue
+                    
+                # Se uma contém a outra (ex: "donald trump" contém "trump")
+                if other in entity or entity in other:
+                    # Usar a mais completa como canônica
+                    if len(entity) >= len(other):
+                        normalization_map[(other, etype)] = (entity, etype)
+                    else:
+                        normalization_map[(entity, etype)] = (other, etype)
+                        canonical = other
+                        
+            # Mapear para si mesmo se não foi mapeado
+            if (entity, etype) not in normalization_map:
+                normalization_map[(entity, etype)] = (canonical, etype)
+    
+    # Aplicar normalização
+    normalized_docs = []
+    for entities in entities_by_doc:
+        normalized = []
+        seen = set()
+        for text, etype in entities:
+            canonical = normalization_map.get((text, etype), (text, etype))
+            if canonical not in seen:
+                seen.add(canonical)
+                normalized.append(canonical)
+        normalized_docs.append(normalized)
+    
+    logging.info(f"Normalização: {len(all_entities)} tipos, mapa com {len(normalization_map)} entradas")
+    return normalized_docs
 
 def build_entity_graph(entities_by_doc: List[List[Tuple[str, str]]], 
                        positions: List[Dict]) -> Dict[str, Any]: