Update app.py

app.py

@@ -84,57 +84,99 @@ def calcular_tempo_parcelas(combinacao):
         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
     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:
-        tol_cred, tol_ent, tol_par = 0.50, 0.50, 1.00
-        max_cotas = 25
+        tolerancia_credito = 0.50
+        tolerancia_entrada = 0.50
+        tolerancia_parcela = 1.00
+        max_cotas_combinacao = 25
+        max_combinacoes_por_adm = 7000
     elif credito > 100000:
-        tol_cred, tol_ent, tol_par = 0.25, 0.25, 0.50
-        max_cotas = 15
+        tolerancia_credito = 0.25
+        tolerancia_entrada = 0.25
+        tolerancia_parcela = 0.50
+        max_cotas_combinacao = 15
+        max_combinacoes_por_adm = 4000
     else:
-        tol_cred, tol_ent, tol_par = 0.15, 0.15, 0.30
-        max_cotas = 15
+        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 - tol_cred)
-    cred_max = credito * (1 + tol_cred)
-    ent_min = entrada * (1 - tol_ent)
-    ent_max = entrada * (1 + tol_ent)
-    parc_min = parcela * (1 - tol_par)
-    parc_max = parcela * (1 + tol_par)
+    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)
 
     resultados = []
+    total_combinacoes_testadas = 0
+
+    # Para cada administradora
     for adm, cotas in grupos.items():
-        for r in range(1, min(max_cotas + 1, len(cotas) + 1)):
-            for comb in itertools.combinations(cotas, r):
-                total_cred = sum(c['valor_credito'] for c in comb)
-                total_ent_base = sum(c['valor_entrada'] for c in comb)
+        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)):
+            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_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 comb)
+                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 comb)
+                    total_saldo = sum(c['saldo_devedor'] for c in combinacao)
                     valor_final = total_ent + total_saldo
                     diff = abs(valor_final - total_cred)
-                    resultados.append((adm, comb, diff))
-                    if len(resultados) >= 30:
+                    resultados.append((adm, combinacao, diff))
+                    
+                    # Se já encontrou 3x o número desejado, interrompe busca
+                    if len(resultados) >= 45:  # 15 * 3
                         break
-            if len(resultados) >= 30:
+            
+            # Sai do loop de r se já temos resultados suficientes
+            if len(resultados) >= 45:
                 break
-        if len(resultados) >= 30:
+        
+        # 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)}")
+
     if not resultados:
-        return "🚫 Nenhuma combinação encontrada."
+        # 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])
     return formatar_resultados(resultados[:15])
 
@@ -175,10 +217,10 @@ def formatar_resultados(resultados):
 """
     return resposta
 
-# Carrega a planilha antes de iniciar
+# Carrega a planilha uma vez no início
 carregar_planilha()
 
-# Interface usando gr.Interface (API automática em /api/predict)
+# Interface Gradio (usando Blocks para maior controle, mas Interface também funciona)
 demo = gr.Interface(
     fn=buscar_combinacoes,
     inputs=[
@@ -193,10 +235,9 @@ demo = gr.Interface(
         )
     ],
     outputs=gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40),
-    title="🚗 Busca de Combinações de Consórcio Auto",
+    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."
 )
 
 if __name__ == "__main__":
-    demo.launch()
-#
+    demo.launch()