Update app.py

app.py

@@ -65,14 +65,12 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
     """Busca combinações de cotas dentro dos parâmetros especificados."""
     # Garante que o DataFrame está carregado
     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."
 
     # Filtra por tipo de bem e administradoras
     df_filtrado = df[df['tipo_do_bem'].str.lower() == 'imovel']
     if administradoras:
-        # Certifica-se de que administradoras é uma lista (Gradio retorna tupla)
         if isinstance(administradoras, tuple):
             administradoras = list(administradoras)
         df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
@@ -87,14 +85,52 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
 
     grupos = agrupar_por_administradora(df_filtrado)
     resultados = []
+    
+    # ⚡ OTIMIZAÇÃO: Timeout de 30 segundos
+    start_time = time.time()
+    TIME_LIMIT = 30  # segundos
 
     for adm, cotas in grupos.items():
-        # 🔥 ALTERAÇÃO PRINCIPAL: Mudado de 3 para 10 cotas máximas
-        for r in range(1, min(10, len(cotas)) + 1):  # Máximo 10 cotas por combinação ← AQUI!
-            for combinacao in itertools.combinations(cotas, r):
+        if time.time() - start_time > TIME_LIMIT:
+            break
+            
+        # ⚡ OTIMIZAÇÃO: Pré-filtra cotas que individualmente já estão dentro dos limites
+        cotas_filtradas = []
+        for cota in cotas:
+            credito = cota.get('valor_credito', 0)
+            parcela = cota.get('valor_parcela', 0)
+            if (credito_min <= credito <= credito_max and 
+                parcela_min <= parcela <= parcela_max):
+                cotas_filtradas.append(cota)
+        
+        if not cotas_filtradas:
+            continue
+            
+        # ⚡ OTIMIZAÇÃO: Limita para 12 cotas por administradora
+        if len(cotas_filtradas) > 12:
+            # Pega as cotas mais próximas do valor desejado
+            cotas_filtradas.sort(key=lambda x: abs(x.get('valor_credito', 0) - credito_desejado/3))
+            cotas_filtradas = cotas_filtradas[:12]
+        
+        # ⚡ OTIMIZAÇÃO: Busca primeiro combinações menores (mais rápidas)
+        for r in range(1, min(10, len(cotas_filtradas)) + 1):
+            if time.time() - start_time > TIME_LIMIT:
+                break
+                
+            # ⚡ OTIMIZAÇÃO: Amostragem inteligente - não testa todas as combinações
+            max_combinations = 100  # Limite de combinações por tamanho
+            count = 0
+            
+            for combinacao in itertools.combinations(cotas_filtradas, r):
+                if time.time() - start_time > TIME_LIMIT:
+                    break
+                    
+                if count >= max_combinations:
+                    break
+                    
                 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)  # aplica os 8,5% sobre o crédito
+                total_entrada = total_entrada_base + (total_credito * 0.085)
                 total_parcelas = sum(c['valor_parcela'] for c in combinacao)
 
                 if (credito_min <= total_credito <= credito_max and
@@ -103,16 +139,25 @@ 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))
+                    
+                    # ⚡ OTIMIZAÇÃO: Limita resultados por administradora
+                    if len([r for r in resultados if r[0] == adm]) >= 5:
+                        break
+                
+                count += 1
+                
+            if time.time() - start_time > TIME_LIMIT:
+                break
 
     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 formatar_resultados(resultados)
+    return formatar_resultados(resultados[:10])  # Limita a 10 resultados
 
 # ✅ MODIFIQUE A FUNÇÃO PRINCIPAL PARA USAR FALLBACK
 def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):