Update app.py

app.py

@@ -3,18 +3,100 @@ import requests
 import io
 import itertools
 from collections import defaultdict
-import gradio as gr # Importação principal para Gradio
-import os # Para variáveis de ambiente, se necessário
+import gradio as gr
+import os
+from unicodedata import normalize
 
 # 🔧 CONFIGURAÇÕES GLOBAIS
-# O ID da planilha para Consórcio de Automóveis
-# Certifique-se de que este FILE_ID esteja acessível publicamente ou para "Qualquer pessoa com o link"
 FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
 URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 
 # Variável global para armazenar o DataFrame
 df = None
 
+def padronizar_nomes_administradoras(nome):
+    """Padroniza nomes de administradoras com mapeamento específico."""
+    if pd.isna(nome):
+        return nome
+    
+    # Limpeza básica
+    nome_limpo = (
+        str(nome)
+        .strip()
+        .lower()
+        .replace('$', 's')
+        .replace('  ', ' ')
+        .strip()
+    )
+    
+    # Remove acentos
+    nome_limpo = normalize('NFKD', nome_limpo).encode('ASCII', 'ignore').decode('ASCII')
+    
+    # 👇 MAPEAMENTO COMPLETO com suas administradoras corretas
+    mapeamento = {
+        # Correções de nomes errados → nomes corretos
+        'Ademicon': 'Ademicon',
+        'ademicon': 'Ademicon',
+        'ancora': 'Ancora',
+        'banco do brasil': 'Banco do Brasil',
+        'bb': 'Banco do Brasil',
+        'Banrisul': 'Banrisul',
+        'banrisul': 'Banrisul',
+        'Bradesco': 'Bradesco',
+        'bradesco': 'Bradesco',
+        'caixa': 'Caixa XS5',
+        'xs5': 'Caixa XS5',
+        'caixa xs5': 'Caixa XS5',
+        'caixa seguradora': 'Caixa XS5',
+        'cnp': 'Caixa CNP',
+        'Canopus': 'Canopus',
+        'canopus': 'Canopus',
+        'disal': 'Disal',
+        'disal consorcios': 'Disal',
+        'Embracon': 'Embracon',
+        'embracon': 'Embracon',
+        'ford': 'Ford',
+        'honda': 'Honda',
+        'hs': 'HS',
+        'hs consorcio': 'HS',
+        'Maggi': 'Maggi',
+        'maggi': 'Maggi',
+        'Mycon': 'Mycon',
+        'mycon': 'Mycon',
+        'porto': 'Porto Seguro',
+        'porto-vp': 'Porto Seguro VP',
+        'remaza': 'Remaza',
+        'Rodebens': 'Rodobens',
+        'rodobens': 'Rodobens',
+        'Santander': 'Santander',
+        'santander': 'Santander',
+        'scania': 'Scania',
+        'Serello': 'Serello',
+        'serello': 'Serello',
+        'servopa': 'Servopa',
+        'sicoob unicoob': 'Sicoob Unicoob',
+        'sicoobu': 'Sicoob Unicoob',
+        'Sicredi': 'Sicredi',
+        'sicredi': 'Sicredi',
+        'Sponchiado': 'Sponchiado',
+        'sponchiado': 'Sponchiado',
+        'unifisa': 'Unifisa',
+        'Volkswagen': 'Volkswagen',
+        'volkswagen': 'Volkswagen',
+        'yamaha': 'Yamaha',
+        'zema': 'Zema'
+    }
+    
+    return mapeamento.get(nome_limpo, nome_limpo)
+
+def verificar_administradoras():
+    """Mostra como ficaram as administradoras após a padronização."""
+    if df is not None and 'administradora' in df.columns:
+        print("🔍 Administradoras únicas após padronização:")
+        administradoras_unicas = df[df['tipo_do_bem'].str.lower() == 'auto']['administradora'].unique()
+        for i, adm in enumerate(sorted(administradoras_unicas), 1):
+            print(f"{i:2d}. {adm}")
+        print(f"Total: {len(administradoras_unicas)} administradoras")
 
 def carregar_planilha():
     """Carrega e prepara a planilha para análise de consórcios de automóveis."""
@@ -29,10 +111,10 @@ def carregar_planilha():
         # Padroniza nomes das colunas
         df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
 
-        # Padroniza os nomes das administradoras
+        # 👇 NOVA PADRONIZAÇÃO DAS ADMINISTRADORAS
         if 'administradora' in df.columns:
-            df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
-
+            # Aplica a padronização personalizada
+            df['administradora'] = df['administradora'].apply(padronizar_nomes_administradoras)
 
         # Converte colunas numéricas
         numeric_cols = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
@@ -47,11 +129,14 @@ def carregar_planilha():
         # Remove duplicatas
         df.drop_duplicates(inplace=True)
         print("✅ Planilha carregada com sucesso!")
+        
+        # Mostra as administradoras padronizadas
+        verificar_administradoras()
+        
         return True
 
     except Exception as e:
         print(f"❌ Erro ao carregar planilha: {str(e)}")
-        # Retorne uma mensagem de erro mais útil para o usuário
         return False
 
 def agrupar_por_administradora(dataframe):
@@ -73,7 +158,7 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
     if administradoras:
         if isinstance(administradoras, tuple):
             administradoras = list(administradoras)
-        administradoras = [a.strip().lower() for a in administradoras]
+        administradoras = [a.strip() for a in administradoras]
         df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
 
     if df_filtrado.empty:
@@ -86,13 +171,13 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
 
     grupos = agrupar_por_administradora(df_filtrado)
     resultados = []
-    MAX_COMBINACOES_POR_ADM = 50  # Limite para evitar processamento excessivo
+    MAX_COMBINACOES_POR_ADM = 50
 
     for adm, cotas in grupos.items():
-        cotas = cotas[:25]  # Limita a 25 cotas por administradora para evitar combinações explosivas
+        cotas = cotas[:25]
         combinacoes_validas = 0
         
-        for r in range(1, min(6, len(cotas)) + 1):  # Agora até 5 cotas
+        for r in range(1, min(6, len(cotas)) + 1):
             for combinacao in itertools.combinations(cotas, r):
                 if combinacoes_validas >= MAX_COMBINACOES_POR_ADM:
                     break
@@ -116,10 +201,7 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
     if not resultados:
         return "Nenhuma combinação adequada encontrada para automóveis com os parâmetros fornecidos."
 
-    # Ordena por diferença (melhores combinações primeiro)
     resultados.sort(key=lambda x: x[2])
-    
-    # Limita o número total de resultados para evitar sobrecarga
     resultados = resultados[:250]
     
     return formatar_resultados(resultados)
@@ -131,60 +213,36 @@ def formatar_resultados(resultados):
     """Formata os resultados para exibição."""
     resposta = ""
     
-     # 1. Agrupar os resultados por administradora, mantendo a diferença para ordenação interna
-    # grouped_by_adm = {'Administradora X': [(combinacao_A, 100), (combinacao_C, 180), ...],
-    #                   'Administradora Y': [(combinacao_B, 150), ...]}
     grouped_by_adm = defaultdict(list)
     for adm, combinacao, diferenca in resultados:
         grouped_by_adm[adm].append((combinacao, diferenca))
 
-    # 2. Ordenar as combinações dentro de cada administradora pela diferença (do menor para o maior)
     for adm in grouped_by_adm:
-        grouped_by_adm[adm].sort(key=lambda x: x[1]) # x[1] é a diferença
+        grouped_by_adm[adm].sort(key=lambda x: x[1])
 
     final_resultados_diversificados = []
-    
-    # Dicionário para acompanhar o índice da próxima combinação a ser pega de cada administradora
-    # Ex: {'Itau': 0, 'Bradesco': 0, 'Caixa': 0}
     adm_indices = {adm: 0 for adm in grouped_by_adm.keys()}
-
-    # Lista de administradoras ativas (que ainda têm combinações disponíveis)
     active_adms = list(grouped_by_adm.keys())
+    current_adm_idx = 0
     
-    current_adm_idx = 0 # Índice para ciclar entre as administradoras ativas
-    
-    # Loop para selecionar até 15 combinações, garantindo diversidade
     while len(final_resultados_diversificados) < 15 and active_adms:
-        # Pega a administradora da vez para selecionar uma combinação
         adm_da_vez = active_adms[current_adm_idx]
-        
-        # Pega o índice da próxima combinação para essa administradora
         idx_na_adm = adm_indices[adm_da_vez]
         
-        # Verifica se essa administradora ainda tem combinações disponíveis
         if idx_na_adm < len(grouped_by_adm[adm_da_vez]):
-            # Pega a combinação (ignorando a diferença, que já foi usada para ordenar internamente)
             combinacao_data, _ = grouped_by_adm[adm_da_vez][idx_na_adm]
-            
-            # Adiciona à lista de resultados final (com a administradora e a combinação)
             final_resultados_diversificados.append((adm_da_vez, combinacao_data))
-            
-            # Incrementa o índice para a próxima vez que pegarmos dessa administradora
             adm_indices[adm_da_vez] += 1
         else:
-            # Se essa administradora não tem mais combinações, remove ela da lista de ativas
             active_adms.pop(current_adm_idx)
-            # Ajusta o current_adm_idx se a lista diminuiu e estamos no limite
             if current_adm_idx >= len(active_adms) and active_adms:
-                 current_adm_idx = 0 # Volta para o início da lista se removemos o último
+                 current_adm_idx = 0
 
-        # Move para a próxima administradora no ciclo (garantindo que não estouramos o índice da lista active_adms)
-        if active_adms: # Só avança se ainda houver administradoras ativas
+        if active_adms:
             current_adm_idx = (current_adm_idx + 1) % len(active_adms)
         else:
-            break # Não há mais administradoras ativas, sai do loop
+            break
             
-    # Agora, itera sobre os resultados diversificados para formatar a resposta
     for idx, (adm, combinacao) in enumerate(final_resultados_diversificados, 1):
         codigos = [str(c.get('codigo', 'N/A')) for c in combinacao]
         total_credito = sum(c['valor_credito'] for c in combinacao)
@@ -200,14 +258,12 @@ def formatar_resultados(resultados):
         taxa_percentual = (taxa_total / credito_real) * 100 if credito_real > 0 else 0
         taxa_mensal = taxa_percentual / maior_prazo if maior_prazo > 0 else 0
 
-        #comissao = total_entrada * (8.5 / 108.5)
-
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
-�� Administradora: {adm}
+🏢 Administradora: {adm.upper()}
 🔢 Códigos: {', '.join(codigos)}
 💰 Crédito Total: {formatar_moeda(total_credito)}
-�� Entrada (+comissão): {formatar_moeda(total_entrada)}
+💵 Entrada (+comissão): {formatar_moeda(total_entrada)}
 📉 Saldo Devedor: {formatar_moeda(total_saldo)}
 💲 Parcela: {formatar_moeda(total_parcelas)}
 ⏳ Prazo: {maior_prazo} meses
@@ -220,24 +276,25 @@ def formatar_resultados(resultados):
 """
     return resposta
 
-# --- INICIALIZAÇÃO PARA GRADIO ---
-# Carrega a planilha UMA VEZ no início do aplicativo
-# Se der erro, a função de busca tentará carregar novamente.
-if not carregar_planilha():
-    print("⚠️ Aviso: Planilha não carregada na inicialização. Tentará carregar na primeira busca.")
-
-# Calcula a entrada adicionando 8,5% ao valor final da entrada.
 def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
     entrada_calculada = credito_desejado * 0.085 + entrada_desejada
     return buscar_combinacoes(credito_desejado, entrada_calculada, parcela_desejada, administradoras)
 
-# Prepara as opções para o seletor de administradoras do Gradio
 def get_administradoras_options():
-    if df is not None:
-        adm_list = df[df['tipo_do_bem'].str.lower() == 'auto']['administradora'].unique()
-        return sorted(adm_list.tolist()) # Converter para lista, pois .unique() pode retornar um numpy array
+    """Obtém lista de administradoras únicas e padronizadas para o frontend."""
+    if df is not None and 'administradora' in df.columns:
+        adm_list = (
+            df[df['tipo_do_bem'].str.lower() == 'auto']['administradora']
+            .dropna()
+            .unique()
+        )
+        return sorted(adm_list.tolist())
     return []
 
+# --- INICIALIZAÇÃO PARA GRADIO ---
+if not carregar_planilha():
+    print("⚠️ Aviso: Planilha não carregada na inicialização. Tentará carregar na primeira busca.")
+
 # --- Interface Gradio ---
 with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
     gr.HTML("""
@@ -252,7 +309,6 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
             color: black !important;
         }
         
-        /* Inputs Numéricos: Crédito, Entrada, Parcela */
         input[type="number"] {
             background-color: white !important;
             border: 2px solid #000 !important;
@@ -262,7 +318,6 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
             font-weight: 500;
         }
         
-        /* Inputs de texto e áreas de texto (como a saída e código) */
         input[type="text"], textarea {
             background-color: white !important;
             border: 2px solid black !important;
@@ -320,7 +375,7 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
     administradoras_multiselect = gr.CheckboxGroup(
         label="Filtrar por Administradoras",
         choices=administradoras_options,
-        value=administradoras_options, # Seleciona todas por padrão
+        value=administradoras_options,
         interactive=True
     )
 
@@ -328,16 +383,14 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
 
     output_text = gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40, interactive=False, placeholder="Os resultados aparecerão aqui...")
 
-    # Conecta o botão à função de busca
     submit_btn.click(
         fn=ajustar_e_buscar,
         inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect],
         outputs=output_text
     )
 
-
     gr.Markdown("---")
     gr.Markdown("Ferramenta desenvolvida para otimizar a busca por consórcios de automóveis.")
 
 if __name__ == "__main__":
-    demo.launch() # Você não precisa disso no Colab, mas sim no arquivo que você fará o deploy
+    demo.launch()