Update app.py

app.py

@@ -1,12 +1,10 @@
-# app.py - VERSÃO COM TEMPO DE PARCELAS
+# app.py - VERSÃO COM MARGEM ABSOLUTA FIXA
 import pandas as pd
 import requests
 import io
 import itertools
 from collections import defaultdict
 import gradio as gr
-import time
-import math
 
 # 🔧 CONFIGURAÇÕES GLOBAIS
 FILE_ID = "1XvNz7DlWioT64uNdcfBSL8Ui2nRSi9gT"
@@ -21,11 +19,10 @@ planilha_carregada = False
 def carregar_planilha():
     """Carrega e prepara a planilha para análise."""
     global df, df_imovel, grupos_imovel, planilha_carregada
-    
-    # Se já carregou, não precisa carregar novamente
+
     if planilha_carregada:
         return True
-        
+
     try:
         print("⏳ Carregando planilha...")
         response = requests.get(URL)
@@ -36,7 +33,7 @@ def carregar_planilha():
         # Padroniza nomes das colunas
         df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
 
-        # Converte colunas numéricas
+        # 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:
@@ -46,10 +43,9 @@ def carregar_planilha():
         if 'tipo_do_bem' not in df.columns or 'administradora' not in df.columns:
             raise ValueError("Colunas essenciais não encontradas")
 
-        # Remove duplicatas
         df.drop_duplicates(inplace=True)
-        
-        # Pré-filtra e pré-processa dados de imóvel
+
+        # Pré‑processa imóvel
         df_imovel = df[df['tipo_do_bem'].str.lower() == 'imovel'].copy()
         grupos_imovel = agrupar_por_administradora(df_imovel)
 
@@ -63,6 +59,7 @@ def carregar_planilha():
         print(f"❌ Erro ao carregar planilha: {str(e)}")
         return False
 
+
 def agrupar_por_administradora(dataframe):
     """Agrupa cotas por administradora."""
     grupos = defaultdict(list)
@@ -70,38 +67,38 @@ def agrupar_por_administradora(dataframe):
         grupos[row['administradora']].append(row.to_dict())
     return grupos
 
+
+def formatar_moeda(valor):
+    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+
+
 def calcular_tempo_parcelas(combinacao):
-    """Calcula o tempo de parcelas baseado nas cotas da combinação - VERSÃO CORRIGIDA."""
+    """Calcula o tempo de parcelas baseado nas cotas da combinação."""
     if not combinacao:
         return ""
-    
+
     try:
-        # Ordena as cotas pelo prazo (menor prazo primeiro)
         cotas_ordenadas = sorted(combinacao, key=lambda x: int(x.get('qtd_parcelas', 0)))
-        
-        # Encontra todos os prazos únicos e ordena
         prazos = sorted(set(int(c.get('qtd_parcelas', 0)) for c in combinacao))
-        
+
         if not prazos or prazos[0] <= 0:
             return ""
-        
+
         resultado = []
         prazo_anterior = 0
-        
-        for i, prazo_atual in enumerate(prazos):
-            # Calcula a soma das parcelas das cotas que estão ativas neste intervalo
+
+        for prazo_atual in prazos:
             cotas_ativas = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) >= prazo_anterior + 1]
             valor_parcela_total = sum(c.get('valor_parcela', 0) for c in cotas_ativas)
-            
+
             inicio = prazo_anterior + 1
             fim = prazo_atual
-            
+
             if inicio <= fim and valor_parcela_total > 0:
                 resultado.append(f"{inicio}x à {fim}x: {formatar_moeda(valor_parcela_total)}/mês")
-            
+
             prazo_anterior = prazo_atual
-        
-        # Adiciona faixa final se houver cotas com prazos além do último ponto de quebra
+
         if prazos and prazo_anterior < max(prazos):
             cotas_ativas_finais = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) > prazo_anterior]
             if cotas_ativas_finais:
@@ -110,170 +107,92 @@ def calcular_tempo_parcelas(combinacao):
                 fim_final = max(prazos)
                 if valor_parcela_final > 0:
                     resultado.append(f"{inicio_final}x à {fim_final}x: {formatar_moeda(valor_parcela_final)}/mês")
-        
-        return "\n".join(resultado) if resultado else ""
-    
+
+        return "\\n".join(resultado) if resultado else ""
+
     except Exception as e:
         print(f"❌ Erro ao calcular tempo de parcelas: {str(e)}")
         return ""
 
+
+def definir_margens_absolutas(credito_desejado, entrada_desejada, parcela_desejada):
+    """Define margens fixas em R$ para crédito, entrada e parcela."""
+    # Margens em R$ (ex.: 500.000 → 480.000–520.000)
+    margem_credito = 40_000
+    margem_entrada  = 10_000
+    margem_parcela  = 1_000
+
+    credito_min = max(0, credito_desejado - margem_credito)
+    credito_max = credito_desejado + margem_credito
+
+    entrada_min = max(0, entrada_desejada - margem_entrada)
+    entrada_max = entrada_desejada + margem_entrada
+
+    parcela_min = max(0, parcela_desejada - margem_parcela)
+    parcela_max = parcela_desejada + margem_parcela
+
+    return credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max
+
+
+def filtrar_cotas_por_faixa(cotas, credito_min, credito_max):
+    """Filtra cotas que pelo menos têm chance de entrar na faixa de crédito."""
+    return [c for c in cotas if c['valor_credito'] < credito_max * 2]
+
+
 def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=15):
-    """Busca combinações de cotas dentro dos parâmetros especificados de forma otimizada."""
+    """Busca combinações de cotas dentro de margens fixas absolutas."""
     global df_imovel, grupos_imovel
-    
-    # Garante que o DataFrame está carregado
+
     if not planilha_carregada:
         if not carregar_planilha():
             return "❌ Erro: Planilha não carregada. Por favor, tente novamente."
 
-    # Filtra administradoras se especificado
+    # Filtra administradoras
     if administradoras and len(administradoras) > 0:
         grupos_filtrados = {adm: cotas for adm, cotas in grupos_imovel.items() if adm in administradoras}
-        print(f"🔍 Filtrando por administradoras: {administradoras}")
     else:
         grupos_filtrados = grupos_imovel
-        print("🔍 Buscando em todas as administradoras")
 
     if not grupos_filtrados:
         return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
 
     print(f"🔍 Total de administradoras no filtro: {len(grupos_filtrados)}")
-    
-    # TOLERÂNCIAS - Ajustadas para valores altos
-    if credito_desejado > 10000000:
-        tolerancia_credito = 0.50
-        tolerancia_entrada = 0.50
-        tolerancia_parcela = 1.00
-        max_cotas_combinacao = 25
-    else:
-        tolerancia_credito = 0.25
-        tolerancia_entrada = 0.25
-        tolerancia_parcela = 0.50
-        max_cotas_combinacao = 15
-
-    # Define faixas de tolerância
-    credito_min = credito_desejado * (1 - tolerancia_credito)
-    credito_max = credito_desejado * (1 + tolerancia_credito)
-    entrada_min = entrada_desejada * (1 - tolerancia_entrada)
-    entrada_max = entrada_desejada * (1 + tolerancia_entrada)
-    parcela_min = parcela_desejada * (1 - tolerancia_parcela)
-    parcela_max = parcela_desejada * (1 + tolerancia_parcela)
+
+    # Usa margens fixas em R$
+    credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max = definir_margens_absolutas(
+        credito_desejado, entrada_desejada, parcela_desejada
+    )
 
     print(f"💰 Valores desejados: Crédito: R$ {credito_desejado:,.2f}, Entrada: R$ {entrada_desejada:,.2f}, Parcela: R$ {parcela_desejada:,.2f}")
+    print(f"🔍 Margem de crédito: de R$ {credito_min:,.2f} até R$ {credito_max:,.2f}")
+
+    # Limites de busca
+    max_cotas_combinacao = 15
+    max_combinacoes_por_adm = 4000  # para evitar explosão de combinações [web:12][web:18]
 
     resultados = []
     total_combinacoes_testadas = 0
-    
-    # Para cada administradora, busca combinações
+
     for adm, cotas in grupos_filtrados.items():
         print(f"🔍 Analisando administradora: {adm} ({len(cotas)} cotas)")
-        
-        cotas_para_combinar = cotas
-        
-        # Gera combinações
-        for r in range(1, min(max_cotas_combinacao + 1, len(cotas_para_combinar) + 1)):
-            if credito_desejado > 10000000:
-                max_combinacoes_por_adm = 7000
-            else:
-                max_combinacoes_por_adm = 4000
-            combinacoes_geradas = 0
-            
-            for combinacao in itertools.combinations(cotas_para_combinar, r):
-                if combinacoes_geradas >= max_combinacoes_por_adm:
-                    break
-                    
-                total_combinacoes_testadas += 1
-                combinacoes_geradas += 1
-                
-                total_credito = sum(c['valor_credito'] for c in combinacao)
-                total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
-                total_entrada = total_entrada_base + (total_credito * 0.085)
-                total_parcelas = sum(c['valor_parcela'] for c in combinacao)
 
-                # Verifica se a combinação está dentro das tolerâncias
-                if (credito_min <= total_credito <= credito_max and
-                    entrada_min <= total_entrada <= entrada_max and
-                    parcela_min <= total_parcelas <= parcela_max):
+        cotas_filtradas = filtrar_cotas_por_faixa(cotas, credito_min, credito_max)
 
-                    total_saldo = sum(c['saldo_devedor'] for c in combinacao)
-                    valor_final = round(total_entrada + total_saldo, 2)
-                    diferenca = abs(valor_final - total_credito)
-
-                    resultados.append((adm, combinacao, diferenca))
-                    
-                    if len(resultados) >= max_combinacoes * 3:
-                        break
-            
-            if len(resultados) >= max_combinacoes * 3:
-                break
-        
-        if len(resultados) >= max_combinacoes * 3:
-            break
-
-    print(f"🔍 Total de combinações testadas: {total_combinacoes_testadas}")
-    print(f"🔍 Combinações válidas encontradas: {len(resultados)}")
-
-    if not resultados:
-        # Tenta uma busca mais ampla se não encontrou resultados
-        print("🔍 Nenhuma combinação encontrada. Tentando busca ampla...")
-        return buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejada, administradoras, max_combinacoes)
-
-    # Ordena pela diferença e pega as melhores
-    resultados.sort(key=lambda x: x[2])
-    return formatar_resultados(resultados[:max_combinacoes])
-
-def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=15):
-    """Busca combinações com tolerâncias mais amplas para valores altos."""
-    global grupos_imovel
-    
-    # Filtra administradoras se especificado
-    if administradoras and len(administradoras) > 0:
-        grupos_filtrados = {adm: cotas for adm, cotas in grupos_imovel.items() if adm in administradoras}
-    else:
-        grupos_filtrados = grupos_imovel
-
-    # Tolerâncias mais amplas para valores altos
-    if credito_desejado > 10000000:
-        tolerancia_credito = 0.50
-        tolerancia_entrada = 0.50
-        tolerancia_parcela = 1.00
-        max_cotas_combinacao = 25
-    else:
-        tolerancia_credito = 0.25
-        tolerancia_entrada = 0.25
-        tolerancia_parcela = 0.50
-        max_cotas_combinacao = 15
-
-    credito_min = credito_desejado * (1 - tolerancia_credito)
-    credito_max = credito_desejado * (1 + tolerancia_credito)
-    entrada_min = entrada_desejada * (1 - tolerancia_entrada)
-    entrada_max = entrada_desejada * (1 + tolerancia_entrada)
-    parcela_min = parcela_desejada * (1 - tolerancia_parcela)
-    parcela_max = parcela_desejada * (1 + tolerancia_parcela)
-
-    resultados = []
-    total_combinacoes_testadas = 0
-    
-    for adm, cotas in grupos_filtrados.items():
-        print(f"🔍 BUSCA AMPLA - Analisando administradora: {adm}")
-        
-        # Gera combinações
-        for r in range(1, min(max_cotas_combinacao + 1, len(cotas) + 1)):
+        for r in range(1, min(max_cotas_combinacao + 1, len(cotas_filtradas) + 1)):
             combinacoes_geradas = 0
-            max_combinacoes_por_adm = 7000
-            
-            for combinacao in itertools.combinations(cotas, r):
+            for combinacao in itertools.combinations(cotas_filtradas, r):
                 if combinacoes_geradas >= max_combinacoes_por_adm:
                     break
-                    
+
                 total_combinacoes_testadas += 1
                 combinacoes_geradas += 1
-                
+
                 total_credito = sum(c['valor_credito'] for c in combinacao)
                 total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
                 total_entrada = total_entrada_base + (total_credito * 0.085)
                 total_parcelas = sum(c['valor_parcela'] for c in combinacao)
 
+                # Verifica margens fixas
                 if (credito_min <= total_credito <= credito_max and
                     entrada_min <= total_entrada <= entrada_max and
                     parcela_min <= total_parcelas <= parcela_max):
@@ -283,32 +202,31 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
                     diferenca = abs(valor_final - total_credito)
 
                     resultados.append((adm, combinacao, diferenca))
-                    
+
                     if len(resultados) >= max_combinacoes * 2:
                         break
-            
+
             if len(resultados) >= max_combinacoes * 2:
                 break
-        
+
         if len(resultados) >= max_combinacoes * 2:
             break
 
-    print(f"🔍 BUSCA AMPLA: Combinações válidas encontradas: {len(resultados)}")
+    print(f"🔍 Total de combinações testadas: {total_combinacoes_testadas}")
+    print(f"🔍 Combinações válidas encontradas: {len(resultados)}")
 
     if not resultados:
         return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
 
-    resultados.sort(key=lambda x: x[2])
+    resultados.sort(key=lambda x: x[2])  # ordena pela menor diferença
     return formatar_resultados(resultados[:max_combinacoes])
 
-def formatar_moeda(valor):
-    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
 
 def formatar_resultados(resultados):
-    """Formata os resultados para exibição INCLUINDO TEMPO DE PARCELAS CORRETO."""
+    """Formata os resultados para exibição incluindo tempo de parcelas."""
     if not resultados:
         return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
-    
+
     resposta = ""
     for idx, (adm, combinacao, _) in enumerate(resultados, 1):
         codigos = [str(c.get('codigo', 'N/A')) for c in combinacao]
@@ -324,8 +242,7 @@ def formatar_resultados(resultados):
         taxa_total = total_saldo - credito_real
         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
-        
-        # CHAMADA CORRIGIDA para calcular tempo de parcelas
+
         tempo_parcelas = calcular_tempo_parcelas(combinacao)
 
         resposta += f"""
@@ -347,72 +264,42 @@ def formatar_resultados(resultados):
 """
     return resposta
 
+
 # Carrega a planilha uma vez quando o aplicativo inicia
 carregar_planilha()
 
+
 def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
     return buscar_combinacoes_otimizado(
-        credito_desejado, entrada_desejada, parcela_desejada, administradoras, max_combinacoes=15
+        float(credito_desejado or 0),
+        float(entrada_desejada or 0),
+        float(parcela_desejada or 0),
+        administradoras,
+        max_combinacoes=15
     )
 
-# Prepara a lista de administradoras para o Gradio
+
 def get_administradoras_options():
     if df is not None and planilha_carregada:
         adm_list = df[df['tipo_do_bem'].str.lower() == 'imovel']['administradora'].unique()
         return sorted(adm_list)
     return []
 
-# Criando a interface Gradio (mantenha igual)
+
+# Interface Gradio
 with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") 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;
-            border: 2px solid #000 !important;
-            border-radius: 12px !important;
-            color: black !important;
-            padding: 10px !important;
-            font-weight: 500;
-        }
-    
-        /* Inputs de texto e áreas de texto (como a saída e código) */
-        input[type="text"], textarea {
+        * { font-family: 'Poppins', sans-serif !important; }
+        body { background-color: #ff8f00 !important; color: black !important; }
+        input[type="number"], input[type="text"], textarea {
             background-color: white !important;
             border: 2px solid black !important;
             border-radius: 12px !important;
             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;
@@ -420,19 +307,10 @@ 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;
-        }
+        .gr-button:hover { background-color: #fff3e0 !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.")
 
@@ -444,11 +322,10 @@ with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
     administradoras_multiselect = gr.CheckboxGroup(
         label="Filtrar por Administradoras",
         choices=get_administradoras_options(),
-        value=get_administradoras_options() # Seleciona todas por padrão
+        value=get_administradoras_options()
     )
 
     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...")
 
     submit_btn.click(
@@ -460,6 +337,5 @@ with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
     gr.Markdown("---")
     gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio ideais.")
 
-# Inicia o aplicativo Gradio
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()