Update app.py

app.py

@@ -8,6 +8,7 @@ import itertools
 from collections import defaultdict
 import gradio as gr
 
+# 🔧 CONFIGURAÇÕES
 FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
 URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 
@@ -18,58 +19,101 @@ ADMIN_OPCOES = []
 
 def carregar_planilha():
     global df_auto, grupos_auto, planilha_carregada, ADMIN_OPCOES
+
     if planilha_carregada:
         return True
+
     try:
         print("⏳ Carregando planilha...")
         response = requests.get(URL)
         response.raise_for_status()
         data = io.BytesIO(response.content)
         df = pd.read_excel(data)
+
         df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
+
         colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
         for col in colunas_numericas:
             if col in df.columns:
                 df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
+
         if 'tipo_do_bem' not in df.columns or 'administradora' not in df.columns:
             raise ValueError("Colunas essenciais não encontradas")
+
         df.drop_duplicates(inplace=True)
+
         df_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
         df_auto['administradora'] = df_auto['administradora'].astype(str).str.strip().str.lower()
         df_auto = df_auto[df_auto['administradora'].notna() & (df_auto['administradora'] != '')]
+
         grupos_auto = defaultdict(list)
         for _, row in df_auto.iterrows():
             grupos_auto[row['administradora']].append(row.to_dict())
+
         ADMIN_OPCOES = sorted(df_auto['administradora'].unique())
         planilha_carregada = True
+
         print(f"✅ Total de cotas: {len(df_auto)}")
         print(f"✅ Administradoras: {ADMIN_OPCOES}")
         return True
+
     except Exception as e:
         print(f"❌ Erro: {e}")
         return False
 
+
 def formatar_moeda(valor):
     return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
 
+
+def definir_margens_absolutas(credito, entrada, parcela):
+    """Margens fixas em R$ (ex.: 30.000 → 10.000 de margem total = 20k–40k)."""
+    margem_credito = 20_000
+    margem_entrada  = 2_000
+    margem_parcela  = 100
+
+    cred_min = max(0, credito - margem_credito)
+    cred_max = credito + margem_credito
+    ent_min  = max(0, entrada - margem_entrada)
+    ent_max  = entrada + margem_entrada
+    parc_min = max(0, parcela - margem_parcela)
+    parc_max = parcela + margem_parcela
+
+    return cred_min, cred_max, ent_min, ent_max, parc_min, parc_max
+
+
+def filtrar_cotas_por_faixa(cotas, cred_min, cred_max):
+    """Remove cotas que não têm chance real de entrar na faixa de crédito."""
+    return [c for c in cotas if c['valor_credito'] < cred_max * 2]
+
+
 def calcular_tempo_parcelas(combinacao):
+    """Calcula o tempo de parcelas por faixa de prazo."""
     if not combinacao:
         return ""
+
     try:
         cotas_ordenadas = sorted(combinacao, key=lambda x: int(x.get('qtd_parcelas', 0)))
         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 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
+
         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:
@@ -78,111 +122,98 @@ 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 tempo: {e}")
+        print(f"Erro calculando tempo de parcelas: {e}")
         return ""
 
+
 def buscar_combinacoes(credito, entrada, parcela, adm_selecionadas):
-    """Versão otimizada: limita combinações e interrompe cedo."""
     if not planilha_carregada:
         if not carregar_planilha():
             return "❌ Erro: planilha não carregada."
-    
-    # Filtra administradoras selecionadas
+
+    # Filtra administradoras
     if adm_selecionadas:
         grupos = {adm: cotas for adm, cotas in grupos_auto.items() if adm in adm_selecionadas}
     else:
         grupos = grupos_auto
-    
+
     if not grupos:
         return "🚫 Nenhuma cota encontrada com os filtros."
 
-    # Configura tolerâncias e limites de acordo com o valor do crédito
-    if credito > 5000000:
-        tolerancia_credito = 0.50
-        tolerancia_entrada = 0.50
-        tolerancia_parcela = 1.00
-        max_cotas_combinacao = 25
-        max_combinacoes_por_adm = 7000
-    elif credito > 100000:
-        tolerancia_credito = 0.25
-        tolerancia_entrada = 0.25
-        tolerancia_parcela = 0.50
-        max_cotas_combinacao = 15
-        max_combinacoes_por_adm = 4000
-    else:
-        tolerancia_credito = 0.15
-        tolerancia_entrada = 0.15
-        tolerancia_parcela = 0.30
-        max_cotas_combinacao = 15
-        max_combinacoes_por_adm = 4000
-
-    cred_min = credito * (1 - tolerancia_credito)
-    cred_max = credito * (1 + tolerancia_credito)
-    ent_min = entrada * (1 - tolerancia_entrada)
-    ent_max = entrada * (1 + tolerancia_entrada)
-    parc_min = parcela * (1 - tolerancia_parcela)
-    parc_max = parcela * (1 + tolerancia_parcela)
+    print(f"🔍 Total de administradoras: {len(grupos)}")
+
+    # Usa margens ABSOLUTAS em R$
+    cred_min, cred_max, ent_min, ent_max, parc_min, parc_max = definir_margens_absolutas(
+        float(credito or 0),
+        float(entrada or 0),
+        float(parcela or 0)
+    )
+
+    print(f"💰 Crédito desejado: R$ {credito:,.2f}")
+    print(f"🔍 Margem crédito: {cred_min:,.2f} – {cred_max:,.2f}")
+
+    # Limites de busca
+    max_cotas_combinacao = 15
+    max_combinacoes_por_adm = 4000
 
     resultados = []
     total_combinacoes_testadas = 0
 
-    # Para cada administradora
     for adm, cotas in grupos.items():
-        print(f"🔍 Analisando administradora: {adm} ({len(cotas)} cotas)")
-        cotas_para_combinar = cotas
-        
-        # Gera combinações de tamanho 1 até max_cotas_combinacao
-        for r in range(1, min(max_cotas_combinacao + 1, len(cotas_para_combinar) + 1)):
+        print(f"🔍 Administradora: {adm} ({len(cotas)} cotas)")
+        cotas_filtradas = filtrar_cotas_por_faixa(cotas, cred_min, cred_max)
+
+        for r in range(1, min(max_cotas_combinacao + 1, len(cotas_filtradas) + 1)):
             combinacoes_geradas = 0
-            for combinacao in itertools.combinations(cotas_para_combinar, 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_cred = sum(c['valor_credito'] for c in combinacao)
                 total_ent_base = sum(c['valor_entrada'] for c in combinacao)
                 total_ent = total_ent_base + total_cred * 0.085
                 total_parc = sum(c['valor_parcela'] for c in combinacao)
-                
+
                 if (cred_min <= total_cred <= cred_max and
                     ent_min <= total_ent <= ent_max and
                     parc_min <= total_parc <= parc_max):
+
                     total_saldo = sum(c['saldo_devedor'] for c in combinacao)
-                    valor_final = total_ent + total_saldo
+                    valor_final = round(total_ent + total_saldo, 2)
                     diff = abs(valor_final - total_cred)
+
                     resultados.append((adm, combinacao, diff))
-                    
-                    # Se já encontrou 3x o número desejado, interrompe busca
-                    if len(resultados) >= 45:  # 15 * 3
+
+                    if len(resultados) >= 45:
                         break
-            
-            # Sai do loop de r se já temos resultados suficientes
+
             if len(resultados) >= 45:
                 break
-        
-        # Sai do loop de administradoras se já temos resultados suficientes
+
         if len(resultados) >= 45:
             break
 
     print(f"🔍 Total de combinações testadas: {total_combinacoes_testadas}")
-    print(f"🔍 Combinações válidas encontradas: {len(resultados)}")
+    print(f"🔍 Resultados válidos: {len(resultados)}")
 
     if not resultados:
-        # Tenta busca mais ampla (opcional, mas pode ser mantida)
-        # Aqui poderia chamar uma função ampla, mas para simplicidade, retorna mensagem
         return "🚫 Nenhuma combinação encontrada com os parâmetros fornecidos."
 
-    # Ordena pela diferença e pega as 15 melhores
-    resultados.sort(key=lambda x: x[2])
+    resultados.sort(key=lambda x: x[2])  # menor diferença
     return formatar_resultados(resultados[:15])
 
+
 def formatar_resultados(resultados):
     if not resultados:
         return "🚫 Nenhuma combinação adequada encontrada."
+
     resposta = ""
     for idx, (adm, comb, _) in enumerate(resultados, 1):
         codigos = [str(c.get('codigo', 'N/A')) for c in comb]
@@ -192,12 +223,13 @@ def formatar_resultados(resultados):
         total_saldo = sum(c['saldo_devedor'] for c in comb)
         total_parc = sum(c['valor_parcela'] for c in comb)
         maior_prazo = max(int(c.get('qtd_parcelas', 0)) for c in comb)
-        valor_final = total_ent + total_saldo
+        valor_final = round(total_ent + total_saldo, 2)
         cred_real = total_cred - total_ent
         taxa_total = total_saldo - cred_real
         taxa_perc = (taxa_total / cred_real) * 100 if cred_real > 0 else 0
         taxa_mensal = taxa_perc / maior_prazo if maior_prazo > 0 else 0
         tempo = calcular_tempo_parcelas(comb)
+
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
 🏢 Administradora: {adm}
@@ -217,28 +249,67 @@ def formatar_resultados(resultados):
 """
     return resposta
 
-# Carrega a planilha uma vez no início
+
+# Carrega uma vez
 carregar_planilha()
 
-# Interface Gradio (usando Blocks para maior controle, mas Interface também funciona)
-demo = gr.Interface(
-    fn=buscar_combinacoes,
-    inputs=[
-        gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000),
-        gr.Number(label="Entrada Desejada (R$)", value=3000, step=100),
-        gr.Number(label="Parcela Desejada (R$)", value=500, step=10),
-        gr.Dropdown(
-            choices=ADMIN_OPCOES,
-            label="Filtrar por Administradoras",
-            multiselect=True,
-            value=ADMIN_OPCOES
-        )
-    ],
-    outputs=gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40),
-    title="🚗 Busca de Combinações de Consórcio Auto (Otimizado)",
-    description="Insira os valores desejados para crédito, entrada e parcela, e filtre por administradora."
-)
+# Interface Gradio (com Blocks, igual ao imóvel)
+with gr.Blocks(title="🚗 Busca de Consórcio Auto (Otimizado)") 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; }
+        input[type="number"], textarea {
+            background-color: white !important;
+            border: 2px solid black !important;
+            border-radius: 12px !important;
+            color: black !important;
+            padding: 10px !important;
+        }
+        .gr-button {
+            font-weight: bold;
+            border-radius: 10px !important;
+            background-color: white !important;
+            color: black !important;
+            border: 2px solid black !important;
+        }
+    </style>
+    """)
+
+    gr.Markdown("# 🚗 Busca de Combinações de Consórcio Auto")
+    gr.Markdown("Insira os valores desejados para crédito, entrada e parcela, e filtre por administradora.")
+
+    with gr.Row():
+        credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000)
+        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100)
+        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10)
+
+    adm_input = gr.Dropdown(
+        choices=ADMIN_OPCOES,
+        label="Filtrar por Administradoras",
+        multiselect=True,
+        value=ADMIN_OPCOES
+    )
+
+    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(
+        fn=buscar_combinacoes,
+        inputs=[credito_input, entrada_input, parcela_input, adm_input],
+        outputs=output_text
+    )
+
+    gr.Markdown("---")
+    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio automotivo.")
 
+# Inicia o app
 if __name__ == "__main__":
-    demo.launch()
-#
+    demo.launch()