Update enhanced_search_v2.py

enhanced_search_v2.py

@@ -1,20 +1,21 @@
-# enhanced_search_v2.py (Versão Final Absolutamente Completa)
+# enhanced_search_v2.py (Versão Final com Normalização Literal Corrigida)
 ###################################################################################################
 #
 # RESUMO DAS CORREÇÕES E MELHORIAS:
 #
-# 1. PRÉ-PROCESSAMENTO DA QUERY TOTALMENTE REESCRITO:
-#    - LIMPEZA DE SÍMBOLOS: A função `clean_symbols_from_query` agora remove uma gama completa
-#      de aspas e símbolos problemáticos (`´`, ` `` `, `'`, `"`).
-#    - CORREÇÃO ORTOGRÁFICA INTELIGENTE:
-#      a) A ordem original das palavras na query é sempre preservada.
-#      b) As stopwords (ex: "com", "de") são identificadas e IGNORADAS pelo corretor.
-#      c) A correção só é tentada em palavras que NÃO existem no dicionário UNIFICADO vindo do app.py.
-#      d) Isso previne erros como "com" -> "coma" e a alteração de termos técnicos válidos.
+# 1. NORMALIZAÇÃO LITERAL INTELIGENTE (CORREÇÃO PRINCIPAL):
+#    - A função `literal_normalize_text` foi aprimorada para remover símbolos e espaços
+#      do INÍCIO e do FIM da string, tanto na query quanto nos dados do banco.
+#    - Isso corrige o bug em que o "Early Exit" falhava com queries que continham lixo
+#      de copiar/colar (como '/////'), restaurando a inteligência da busca literal.
 #
-# 2. FLUXO DE BUSCA MANTIDO:
-#    - A arquitetura robusta com Early Exit, Blocos Protegido/Amplo e Otimização com IA
-#      permanece a mesma, agora recebendo uma query muito mais limpa e confiável.
+# 2. PRÉ-PROCESSAMENTO ROBUSTO MANTIDO:
+#    - A lógica de correção ortográfica criteriosa, que preserva a ordem e só corrige
+#      palavras fora dos dicionários, permanece.
+#
+# 3. ARQUITETURA FINAL MANTIDA:
+#    - O fluxo com Early Exit, Blocos Protegido/Amplo e Otimização com IA continua sendo
+#      a base do buscador.
 #
 ###################################################################################################
 
@@ -33,20 +34,29 @@ from rank_bm25 import BM25Okapi
 # --- Bloco 1: Funções Auxiliares de Normalização e Limpeza --- #
 
 def literal_normalize_text(text):
+    """
+    Normalização para a busca literal. Remove acentos, converte para minúsculas
+    e remove quaisquer símbolos/espaços do início e do fim da string.
+    """
     if pd.isna(text): return ""
-    return unidecode(str(text).lower())
+    normalized = unidecode(str(text).lower())
+    # CORREÇÃO: Remove lixo do início e do fim, mas preserva símbolos internos (ex: / em multissitio/ressincronizador)
+    return re.sub(r'^\W+|\W+$', '', normalized).strip()
 
 def clean_symbols_from_query(text):
+    """Remove uma gama completa de aspas e símbolos da query para a busca geral."""
     if pd.isna(text): return ""
     return re.sub(r"[´`'\"/*]", "", str(text)).strip()
 
 def normalize_text(text):
+    """Normalização completa, limpando tudo exceto letras, números e espaços."""
     if pd.isna(text): return ""
     normalized = unidecode(str(text).lower())
     normalized = re.sub(r'[^\w\s]', ' ', normalized)
     return re.sub(r'\s+', ' ', normalized).strip()
 
 def get_longest_word(query_text):
+    """Função de fallback para encontrar a palavra mais longa em uma query."""
     words = re.findall(r'\b\w{4,}\b', query_text)
     if not words: return ""
     return max(words, key=len)
@@ -55,6 +65,7 @@ def get_longest_word(query_text):
 # --- Bloco 2: Funções de Formatação e Destaque de Resultados --- #
 
 def format_result(row_data, row_index, match_type="", score=0, **kwargs):
+    """Formata uma linha do DataFrame em um dicionário de resultado padronizado, aplicando regras de negócio."""
     data = row_data.copy()
     is_rol = data.get('Correlacao_Rol', '').strip().lower() == 'sim'
     if not is_rol:
@@ -74,6 +85,7 @@ def format_result(row_data, row_index, match_type="", score=0, **kwargs):
     return result
 
 def _highlight_matches(results, query):
+    """Adiciona tags <b></b> ao redor das palavras da query nos resultados para destaque no frontend."""
     if not query or not results: return results
     stopwords = {'de', 'do', 'da', 'dos', 'das', 'a', 'o', 'e', 'em', 'um', 'uma', 'para', 'com'}
     query_words = {word for word in normalize_text(query).split() if len(word) > 2 and word not in stopwords}
@@ -95,26 +107,32 @@ def _highlight_matches(results, query):
 # --- Bloco 3: Funções de Carregamento de Dados e Modelos --- #
 
 def load_and_prepare_database(db_path):
+    """Carrega a base de dados principal, a normaliza e pré-calcula todas as estruturas de dados para a busca."""
     try:
         print(f"Carregando e preparando a base de dados de: {db_path}...")
         df_original = pd.read_csv(db_path, dtype=str).fillna('')
         search_cols = ['Descricao_TUSS', 'Procedimento_Rol', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4', 'Semantico', 'SUBGRUPO', 'GRUPO', 'CAPITULO']
         df_normalized = df_original.copy()
+
         df_normalized['Codigo_TUSS_literal'] = df_normalized['Codigo_TUSS'].apply(literal_normalize_text)
         df_normalized['Procedimento_Rol_literal'] = df_normalized['Procedimento_Rol'].apply(literal_normalize_text)
         df_normalized['Descricao_TUSS_literal'] = df_normalized['Descricao_TUSS'].apply(literal_normalize_text)
+
         df_normalized['full_text_norm'] = ""
         for col in search_cols:
             if col in df_normalized.columns:
                 df_normalized[f'{col}_norm'] = df_normalized[col].apply(normalize_text)
                 df_normalized['full_text_norm'] += ' ' + df_normalized[f'{col}_norm']
+        
         print("Criando modelo BM25 e calculando frequência de palavras...")
         tokenized_corpus = [doc.split() for doc in df_normalized['full_text_norm']]
         bm25_model = BM25Okapi(tokenized_corpus, k1=1.2)
         print(f"Modelo BM25 otimizado com k1={bm25_model.k1}.")
+
         doc_freq = defaultdict(int)
         for doc_words in tokenized_corpus:
             for word in set(doc_words): doc_freq[word] += 1
+        
         print("Combinando frequências de palavras (masculino/feminino)...")
         combined_doc_freq = {}
         processed_words = set()
@@ -128,19 +146,23 @@ def load_and_prepare_database(db_path):
                 combined_doc_freq[word] = combined_freq
                 combined_doc_freq[pair_word] = combined_freq
                 processed_words.add(word); processed_words.add(pair_word)
-            else: combined_doc_freq[word] = freq
+            else:
+                combined_doc_freq[word] = freq
+        
         print("Criando corpus para busca fuzzy...")
         fuzzy_search_corpus = []
         for index, row in df_normalized.iterrows():
             for col in search_cols:
                 if f'{col}_norm' in row and pd.notna(row[f'{col}_norm']):
                     if val := row[f'{col}_norm']: fuzzy_search_corpus.append((val, index))
+        
         print(f"Base de dados pronta com {len(df_original)} procedimentos.")
         return df_original, df_normalized, fuzzy_search_corpus, bm25_model, combined_doc_freq
     except Exception as e:
         print(f"Erro crítico ao carregar/preparar a base de dados: {e}"); raise
 
 def load_correction_corpus(dict_path, column_name='Termo_Correto'):
+    """Carrega um corpus para correção ortográfica, retornando termos originais, normalizados e um set de palavras."""
     try:
         df_dict = pd.read_csv(dict_path, dtype=str).fillna('')
         if column_name not in df_dict.columns: return [], [], set()
@@ -151,6 +173,7 @@ def load_correction_corpus(dict_path, column_name='Termo_Correto'):
     except (FileNotFoundError, Exception): return [], [], set()
 
 def load_general_dictionary(path):
+    """Carrega o dicionário geral de português."""
     try:
         with open(path, 'r', encoding='utf-8') as f: words = {normalize_text(line.strip()) for line in f if line.strip()}
         print(f"Dicionário geral carregado com {len(words)} palavras.")
@@ -158,11 +181,14 @@ def load_general_dictionary(path):
     except (FileNotFoundError, Exception): return set()
 
 # --- Bloco 4: Funções de Reclassificação, Boosts e IA --- #
+
 def create_unified_document_text(result_dict):
+    """Cria um único texto representativo de um procedimento para ser usado pelo Cross-Encoder da IA."""
     text_parts = { result_dict.get(key, '') for key in ['Descricao_TUSS', 'Procedimento_Rol', 'Semantico', 'SUBGRUPO', 'GRUPO', 'CAPITULO', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4']}
     return ". ".join(sorted([part for part in text_parts if part and str(part).strip()]))
 
 def rerank_with_cross_encoder(query, results_list, model):
+    """Usa a IA (Cross-Encoder) para calcular o score semântico. Para o Bloco Amplo, também reordena a lista."""
     if not model or not results_list or not query:
         return results_list, "Cross-Encoder não fornecido ou lista de candidatos vazia."
     sentence_pairs = [[query, create_unified_document_text(result)] for result in results_list]
@@ -183,6 +209,7 @@ def rerank_with_cross_encoder(query, results_list, model):
         return results_list, log_message
 
 def apply_boosts(results, query_words, doc_freq):
+    """Aplica boosts de relevância para jargões e termos ultra-raros ao Bloco Amplo."""
     if not results or not query_words: return results, []
     log_messages = []
     jargon_terms = {w for w in query_words if doc_freq.get(w, 0) <= 15 and len(w) > 4}
@@ -219,7 +246,7 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
     # --- Etapa 1: Pré-processamento inicial ---
     query_para_literal = literal_normalize_text(original_query)
     response["search_log"].append(f"\n--- Etapa 1: Pré-processamento da Query ---")
-    response["search_log"].append(f"Query para busca literal: '{query_para_literal}'")
+    response["search_log"].append(f"Query para busca literal (após limpeza de bordas): '{query_para_literal}'")
 
     # --- Etapa 2: Camada de Early Exit ---
     response["search_log"].append("\n--- Etapa 2: Camada de Early Exit (Literal) ---")
@@ -247,12 +274,12 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
     # --- Etapa 3: Busca Completa (se não houve Early Exit) ---
     query_para_geral = clean_symbols_from_query(original_query)
     response["search_log"].append(f"Query para busca geral (após limpeza de símbolos): '{query_para_geral}'")
-
+    
     original_correction_corpus, normalized_correction_corpus = correction_corpus
     stopwords = {'de', 'do', 'da', 'dos', 'das', 'a', 'o', 'e', 'em', 'um', 'uma', 'para', 'com'}
     final_query_words = []
     words_were_corrected = False
-
+    
     for word in query_para_geral.split():
         norm_word = normalize_text(word)
         is_candidate_for_correction = ( len(norm_word) > 2 and norm_word not in stopwords and not norm_word.isdigit() and norm_word not in valid_words_set )
@@ -269,7 +296,7 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
             final_query_words.append(word)
 
     query_corrigida = " ".join(final_query_words)
-    if words_were_corrected and query_corrigida != query_para_geral:
+    if words_were_corrected and query_corrigida.strip() != query_para_geral.strip():
         response["was_corrected"] = True
         response["corrected_query"] = query_corrigida
         response["search_log"].append(f"Correção ortográfica aplicada: '{query_para_geral}' -> '{query_corrigida}'")
@@ -278,9 +305,7 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
     query_words = [word for word in normalized_query.split() if word not in stopwords and len(word) > 1]
     
     final_list = []
-    # (O restante do código, incluindo feedback, blocos, etc., continua aqui, completo e sem alterações)
     
-    # Camada -1: Prioridade por Feedback de Usuário
     response["search_log"].append("\n--- Etapa 3.1: Verificação de Feedback de Usuário ---")
     query_norm_fb = normalize_text(response.get("corrected_query") or original_query)
     if user_best_matches_counts and query_norm_fb in user_best_matches_counts:
@@ -296,24 +321,20 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
                         seen_indices.add(index)
     response["search_log"].append(f"{len(final_list)} resultado(s) adicionado(s) por feedback de usuário.")
 
-    # Bloco Protegido
     protected_candidates = []
     response["search_log"].append("\n--- Etapa 3.2: Coleta de Candidatos do Bloco Protegido ---")
     
-    # Camada 1: Busca Exata (Score 100)
     exact_fields = [f"{col}_norm" for col in ['Codigo_TUSS', 'Descricao_TUSS', 'Procedimento_Rol', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4', 'Semantico']]
     for field in exact_fields:
         if field in df_normalized.columns:
             for index in df_normalized.index[(df_normalized[field] == normalized_query) & (~df_normalized.index.isin(seen_indices))]:
                 protected_candidates.append(format_result(df_original.loc[index], index, "Exato", 100)); seen_indices.add(index)
             
-    # Camada 2: Frase Exata (Score 99)
     if len(query_words) > 1:
         phrase_pattern = r'\b' + re.escape(normalized_query) + r'\b'
         for index in df_normalized.index[df_normalized['full_text_norm'].str.contains(phrase_pattern, na=False, regex=True) & ~df_normalized.index.isin(seen_indices)]:
             protected_candidates.append(format_result(df_original.loc[index], index, "Frase Exata", 99)); seen_indices.add(index)
 
-    # Camada 3: Lógica (E) por Campo (Score 98)
     search_fields_norm = [f"{col}_norm" for col in ['Descricao_TUSS', 'Procedimento_Rol', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4', 'Semantico']]
     for field in search_fields_norm:
         if field in df_normalized.columns:
@@ -322,17 +343,14 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
             for index in df_normalized.index[mask & ~df_normalized.index.isin(seen_indices)]:
                 protected_candidates.append(format_result(df_original.loc[index], index, "Lógica (E)", 98)); seen_indices.add(index)
     
-    # Bloco Amplo
     broad_candidates = []
     response["search_log"].append("\n--- Etapa 3.3: Coleta de Candidatos do Bloco Amplo ---")
 
-    # Camada 4: Busca Fuzzy
     for match_text, score in process.extractBests(normalized_query, [item[0] for item in fuzzy_search_corpus], scorer=fuzz.token_set_ratio, limit=20, score_cutoff=88):
         for _, index in [item for item in fuzzy_search_corpus if item[0] == match_text]:
             if index not in seen_indices:
                 broad_candidates.append(format_result(df_original.loc[index], index, "Aproximação", score)); seen_indices.add(index)
 
-    # Camada 5: Busca BM25
     if query_words:
         bm25_scores = bm25_model.get_scores(query_words)
         max_score = max(bm25_scores) if any(s > 0 for s in bm25_scores) else 1.0
@@ -342,7 +360,6 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
                 index = df_normalized.index[i]
                 broad_candidates.append(format_result(df_original.loc[index], index, "Relevância (BM25)", (bm25_scores[i]/max_score)*95)); seen_indices.add(index)
 
-    # --- Etapa 4: Processamento e Montagem Final ---
     response["search_log"].append("\n--- Etapa 4: Processamento dos Blocos ---")
     
     if protected_candidates:
@@ -363,6 +380,7 @@ def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_co
     response["final_semantic_results"] = _highlight_matches(final_list[:20], query_corrigida)
     end_time = time.time(); response["search_duration_seconds"] = round(end_time - start_time, 4)
     response["search_log"].append(f"\nBusca completa em {response['search_duration_seconds']} segundos.")
+    
     print("\n\n" + "="*20 + " LOG DE BUSCA FINAL " + "="*20)
     print("\n".join(response["search_log"]))