Update enhanced_search_v2.py

enhanced_search_v2.py

@@ -5,10 +5,10 @@
 #
 # Funcionalidades Principais:
 # 1. Correção Ortográfica PRÉ-BUSCA: Corrige termos inválidos ANTES de qualquer busca.
-# 2. Camada 0 para Busca Exata Robusta: Encontra correspondências exatas do conteúdo,
+# 2. Camada 0 para Busca Literal Robusta: Encontra correspondências exatas da frase,
 #    ignorando caixa, acentos, pontuação e espaçamento.
 # 3. Early Exit Otimizado: Interrompe a busca com log claro e correto.
-# 4. Busca em Múltiplas Camadas: Da mais restrita (exata) à mais abrangente (ponderada).
+# 4. Busca em Múltiplas Camadas: Da mais restrita (literal) à mais abrangente (ponderada).
 # 5. Pontuação por Relevância (IDF): Palavras raras têm mais peso.
 # 6. Limpeza de Dados: Zera campos do Rol para procedimentos que não são do Rol.
 # 7. Reordenação Semântica: Usa o MiniLM-L6-v2 para entender o significado e reordenar.
@@ -28,14 +28,17 @@ from collections import defaultdict
 
 # --- FUNÇÕES AUXILIARES DE NORMALIZAÇÃO ---
 
+### ALTERAÇÃO ###
 def literal_normalize_text(text):
     """
     Normaliza o texto para busca literal (Camada 0): minúsculas, sem acentos,
-    sem pontuação e com espaços padronizados.
+    substitui pontuação por espaço e padroniza espaços em branco.
     """
     if pd.isna(text): return ""
     normalized = unidecode(str(text).lower())
-    normalized = re.sub(r'[^\w\s]', '', normalized)
+    # CORREÇÃO: Substitui caracteres não-alfanuméricos por um espaço em vez de removê-los.
+    # Isso impede que palavras como "sangue." e "O" se fundam em "sangueO".
+    normalized = re.sub(r'[^\w\s]', ' ', normalized)
     return re.sub(r'\s+', ' ', normalized).strip()
 
 def normalize_text(text):
@@ -206,31 +209,31 @@ def _run_search_layers(literal_query, normalized_query, response, df_original, d
     stopwords = {'de', 'do', 'da', 'dos', 'das', 'a', 'o', 'e', 'em', 'um', 'uma', 'para', 'com'}
     query_words = [word for word in normalized_query.split() if word not in stopwords and len(word) > 1]
 
-    # --- CAMADA 0: Busca Exata (Normalizada) --- ### ALTERAÇÃO NO TÍTULO ###
+    ### ALTERAÇÃO ###
+    # --- CAMADA 0: Busca Literal (Contida) ---
+    # Esta é a lógica correta para encontrar uma frase inteira dentro de um texto maior.
     if literal_query:
         temp_results = []
         literal_cols = ['Codigo_TUSS_literal', 'Descricao_TUSS_literal', 'Procedimento_Rol_literal']
         for col in literal_cols:
             if col in df_normalized.columns:
-                ### ALTERAÇÃO PRINCIPAL AQUI ###
-                # Trocamos a busca por 'contains' com regex por uma comparação exata '=='.
-                # Isso funciona porque tanto 'literal_query' quanto as colunas '*_literal'
-                # já foram normalizadas da mesma forma (sem acentos, caixa baixa, espaços padronizados).
-                mask = df_normalized[col] == literal_query
-                
+                # Lógica restaurada: Busca pela frase/palavra inteira contida no texto.
+                # O '\b' (word boundary) garante que "sulta" não encontre "consulta",
+                # mas "consulta" encontre "consulta com especialista".
+                # Isso agora funciona corretamente graças à correção em literal_normalize_text.
+                mask = df_normalized[col].str.contains(r'\b' + re.escape(literal_query) + r'\b', na=False)
                 matches = df_normalized[mask]
                 for index, _ in matches.iterrows():
                     if index not in matched_indices:
-                        ### ALTERAÇÃO ### - Atualiza o tipo de match para refletir a nova lógica.
-                        match_type = "Código Exato" if "Codigo" in col else "Texto Exato"
+                        match_type = "Código Literal" if "Codigo" in col else "Texto Literal"
                         temp_results.append(format_result(df_original.loc[index], match_type, 100))
                         matched_indices.add(index)
         if temp_results:
             response["results_by_layer"]["literal_matches"] = sorted(temp_results, key=lambda x: x['Codigo_TUSS'])[:limit_per_layer]
-            ### ALTERAÇÃO ### - Atualiza o nome da camada de saída para o log.
-            return "Busca Exata"
+            return "Busca Literal"
 
     # --- CAMADA 1: Busca Normalizada Exata ---
+    # Esta camada agora serve para quando o texto da busca é *exatamente* igual ao da célula.
     temp_results = []
     if normalized_query:
         exact_code_matches = df_normalized[df_normalized['Codigo_TUSS_norm'] == normalized_query]
@@ -433,8 +436,7 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
     all_candidates = []
     layer_order = ["literal_matches", "exact_matches", "logical_matches", "almost_exact_matches", "contains_matches", "term_matches", "keyword_matches"]
     
-    ### ALTERAÇÃO ### - Atualiza o nome da camada no log final
-    layer_names_map = {"literal_matches": "0. Busca Exata", "exact_matches": "1. Normalizada Exata", "logical_matches": "2. Lógica 'E'",
+    layer_names_map = {"literal_matches": "0. Busca Literal", "exact_matches": "1. Normalizada Exata", "logical_matches": "2. Lógica 'E'",
                        "almost_exact_matches": "3. Quase Exatos (Fuzzy)", "contains_matches": "4. Termos Validados",
                        "term_matches": "5. Busca Ponderada (IDF)", "keyword_matches": "6. Fallback (Palavra-Chave)"}