Update app.py

app.py

@@ -23,7 +23,7 @@ URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 df = None
 
 def carregar_planilha():
-    """Carrega e prepara a planilha para análise."""
+    """Carrega e prepara a planilha para análise de consórcios de automóveis."""
     global df
     try:
         print("⏳ Carregando planilha...")
@@ -35,24 +35,29 @@ def carregar_planilha():
         # Padroniza nomes das colunas
         df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
 
+        # Padroniza os nomes das administradoras
+        if 'administradora' in df.columns:
+            df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
+
+
         # Converte colunas numéricas
-        colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
-        for coluna in colunas_numericas:
-            if coluna in df.columns:
-                df[coluna] = pd.to_numeric(df[coluna], errors='coerce').fillna(0)
+        numeric_cols = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
+        for col in numeric_cols:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
 
         # Verifica colunas essenciais
         if 'tipo_do_bem' not in df.columns or 'administradora' not in df.columns:
-            raise ValueError("Colunas essenciais não encontradas")
+            raise ValueError("Colunas essenciais não encontradas na planilha")
 
         # Remove duplicatas
         df.drop_duplicates(inplace=True)
-
-        print("✅ Planilha carregada com sucesso")
+        print("✅ Planilha carregada com sucesso!")
         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):
@@ -63,34 +68,36 @@ def agrupar_por_administradora(dataframe):
     return grupos
 
 def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de cotas dentro dos parâmetros especificados."""
-    # Garante que o DataFrame está carregado
+    """Busca combinações de cotas para automóveis dentro dos parâmetros especificados."""
+    # Garante que o DataFrame está carregado antes de cada busca
+    # Isso é útil caso a sessão expire ou o DF seja limpo por algum motivo no servidor do HF.
+    global df
     if df is None:
-        # Tenta carregar se ainda não foi carregado
         if not carregar_planilha():
-            return "❌ Erro: Planilha não carregada. Por favor, tente novamente."
+            return "❌ Erro: Planilha não carregada. Verifique se o ID do arquivo está correto e público."
 
-    # Filtra por tipo de bem e administradoras
-    df_filtrado = df[df['tipo_do_bem'].str.lower() == 'imovel']
+    # Filtra por tipo de bem (Auto) e administradoras selecionadas
+    df_filtrado = df[df['tipo_do_bem'].str.lower() == 'auto']
     if administradoras:
-        # Certifica-se de que administradoras é uma lista (Gradio retorna tupla)
-        if isinstance(administradoras, tuple):
+        if isinstance(administradoras, tuple):  # Gradio SelectMultiple retorna uma tupla
             administradoras = list(administradoras)
+        administradoras = [a.strip().lower() for a in administradoras]  # Normaliza os nomes
         df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
 
+
     if df_filtrado.empty:
-        return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
+        return "🚫 Nenhuma cota de automóvel encontrada com os filtros aplicados."
 
     # Define faixas de tolerância
     credito_min, credito_max = credito_desejado * 0.93, credito_desejado * 1.07
     entrada_min, entrada_max = entrada_desejada * 0.93, entrada_desejada * 1.07
-    parcela_min, parcela_max = parcela_desejada * 0.75, parcela_desejada * 1.25
+    parcela_min, parcela_max = parcela_desejada * 0.5, parcela_desejada * 1.5
 
     grupos = agrupar_por_administradora(df_filtrado)
     resultados = []
 
     for adm, cotas in grupos.items():
-        for r in range(1, min(3, len(cotas)) + 1):  # Máximo 3 cotas por combinação
+        for r in range(1, min(3, len(cotas)) + 1): # Máximo 3 cotas por combinação
             for combinacao in itertools.combinations(cotas, r):
                 total_credito = sum(c['valor_credito'] for c in combinacao)
                 total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -103,15 +110,14 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
 
                     total_saldo = sum(c['saldo_devedor'] for c in combinacao)
                     valor_final = round(total_entrada + total_saldo, 2)
-                    diferenca = abs(valor_final - total_credito) # Diferença do valor final pelo crédito (para ordenação)
+                    diferenca = abs(valor_final - total_credito)
 
                     resultados.append((adm, combinacao, diferenca))
 
     if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
-
-    resultados.sort(key=lambda x: x[2]) # Ordena pela diferença
+        return "Nenhuma combinação adequada encontrada para automóveis com os parâmetros fornecidos."
 
+    resultados.sort(key=lambda x: x[2])
     return formatar_resultados(resultados)
 
 def formatar_moeda(valor):
@@ -120,8 +126,62 @@ def formatar_moeda(valor):
 def formatar_resultados(resultados):
     """Formata os resultados para exibição."""
     resposta = ""
-    # Limita a 15 resultados para evitar saídas muito longas
-    for idx, (adm, combinacao, _) in enumerate(resultados[:15], 1):
+    
+     # 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
+
+    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 # Í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
+
+        # 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
+            current_adm_idx = (current_adm_idx + 1) % len(active_adms)
+        else:
+            break # Não há mais administradoras ativas, sai do loop
+            
+    # 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)
         total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -136,12 +196,14 @@ 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}
 🔢 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
@@ -153,34 +215,38 @@ def formatar_resultados(resultados):
 """
     return resposta
 
-# Carrega a planilha uma vez quando o aplicativo inicia
-carregar_planilha()
+# --- 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 a lista de administradoras para o Gradio
+# 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() == 'imovel']['administradora'].unique()
-        return sorted(adm_list)
+        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
     return []
 
-# Criando a interface Gradio
-with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
+# --- Interface Gradio ---
+with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
     gr.HTML("""
     <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
     <style>
         * {
             font-family: 'Poppins', sans-serif !important;
         }
-    
+        
         body {
             background-color: #ff8f00 !important;
             color: black !important;
         }
-    
+        
         /* Inputs Numéricos: Crédito, Entrada, Parcela */
         input[type="number"] {
             background-color: white !important;
@@ -190,7 +256,7 @@ with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
             padding: 10px !important;
             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;
@@ -199,25 +265,25 @@ with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
             color: black !important;
             padding: 10px !important;
         }
-    
+        
         input::placeholder, textarea::placeholder {
             color: #333 !important;
             opacity: 0.7;
         }
-    
+        
         .gr-checkbox label {
             display: flex;
             align-items: center;
             gap: 8px;
             font-weight: 600;
         }
-    
+        
         input[type="checkbox"] {
             accent-color: black !important;
             width: 18px;
             height: 18px;
         }
-    
+        
         .gr-button {
             font-weight: bold;
             border-radius: 10px !important;
@@ -225,46 +291,48 @@ with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
             color: black !important;
             border: 2px solid black !important;
         }
-    
+        
         .gr-button:hover {
             background-color: #fff3e0 !important;
             color: black !important;
         }
-    
+        
         label {
             font-weight: 600 !important;
         }
     </style>
     """)
-
-
-    gr.Markdown("# 🏠 Busca de Combinações de Consórcio Imóvel")
-    gr.Markdown("Insira os valores desejados para crédito, entrada e parcela, e filtre por administradora.")
+    
+    gr.Markdown("# 🚗 Sistema de Busca de Combinações de Consórcio (Automóveis)")
+    gr.Markdown("Preencha os campos abaixo para encontrar as melhores combinações de cotas de consórcio de veículo.")
 
     with gr.Row():
-        credito_input = gr.Number(label="Crédito Desejado (R$)", value=300000, step=1000)
-        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=30000, step=1000)
-        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=1500, step=100)
+        credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000, interactive=True)
+        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100, interactive=True)
+        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10, interactive=True)
 
+    administradoras_options = get_administradoras_options()
     administradoras_multiselect = gr.CheckboxGroup(
         label="Filtrar por Administradoras",
-        choices=get_administradoras_options(),
-        value=get_administradoras_options() # Seleciona todas por padrão
+        choices=administradoras_options,
+        value=administradoras_options, # Seleciona todas por padrão
+        interactive=True
     )
 
     submit_btn = gr.Button("🔍 Buscar Combinações", variant="primary")
 
     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("Desenvolvido para auxiliar na busca por cotas de consórcio ideais.")
+    gr.Markdown("Ferramenta desenvolvida para otimizar a busca por consórcios de automóveis.")
 
-# Inicia o aplicativo Gradio
 if __name__ == "__main__":
     demo.launch() # Você não precisa disso no Colab, mas sim no arquivo que você fará o deploy