Update app.py

app.py

@@ -61,28 +61,17 @@ def agrupar_por_administradora(dataframe):
         grupos[row['administradora']].append(row.to_dict())
     return grupos
 
-def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de cotas com tolerâncias automáticas."""
+def buscar_combinacoes_rapido(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
+    """Busca combinações de até 10 cotas em até 20 segundos."""
     try:
         if df is None:
             if not carregar_planilha():
                 return "❌ Erro: Planilha não carregada."
 
-        print(f"🔍 Buscando: Crédito={credito_desejado}, Entrada={entrada_desejada}, Parcela={parcela_desejada}")
-        
-        # ✅ TOLERÂNCIAS AUTOMÁTICAS BASEADAS NO VALOR
-        if credito_desejado > 1000000:
-            # Valores altos: tolerâncias mais amplas
-            credito_min, credito_max = credito_desejado * 0.70, credito_desejado * 1.30
-            entrada_min, entrada_max = entrada_desejada * 0.50, entrada_desejada * 1.50
-            parcela_min, parcela_max = parcela_desejada * 0.40, parcela_desejada * 2.50
-        else:
-            # Valores normais: tolerâncias padrão
-            credito_min, credito_max = credito_desejado * 0.80, credito_desejado * 1.20
-            entrada_min, entrada_max = entrada_desejada * 0.70, entrada_desejada * 1.30
-            parcela_min, parcela_max = parcela_desejada * 0.60, parcela_desejada * 1.80
-
-        print(f"📈 Tolerâncias: Crédito={credito_min}-{credito_max}, Entrada={entrada_min}-{entrada_max}, Parcela={parcela_min}-{parcela_max}")
+        # ⚡ TOLERÂNCIAS AMPLAS PARA ENCONTRAR RESULTADOS RÁPIDO
+        credito_min, credito_max = credito_desejado * 0.80, credito_desejado * 1.20
+        entrada_min, entrada_max = entrada_desejada * 0.70, entrada_desejada * 1.30
+        parcela_min, parcela_max = parcela_desejada * 0.60, parcela_desejada * 1.50
 
         # Filtra por tipo de bem
         df_filtrado = df[df['tipo_do_bem'].str.lower() == 'imovel']
@@ -93,35 +82,47 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
             df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
 
         if df_filtrado.empty:
-            return "🚫 Nenhuma cota encontrada com os filtros aplicados."
+            return "🚫 Nenhuma cota encontrada."
 
         grupos = agrupar_por_administradora(df_filtrado)
         resultados = []
+        
         MIN_COTAS = 3
-        MAX_COTAS = 6
+        MAX_COTAS = 10
+        MAX_RESULTADOS = 15
+        start_time = time.time()
 
         for adm, cotas in grupos.items():
-            # ✅ FILTRO RÁPIDO: apenas cotas com valores razoáveis
+            if time.time() - start_time > 18:  # ⏰ Limite de 18 segundos
+                break
+                
+            if len(cotas) < MIN_COTAS:
+                continue
+
+            # ⚡ PRÉ-FILTRO RÁPIDO: cotas dentro das tolerâncias individuais
             cotas_validas = []
             for cota in cotas:
-                try:
-                    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_validas.append(cota)
-                except:
-                    continue
+                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_validas.append(cota)
 
             if len(cotas_validas) < MIN_COTAS:
                 continue
 
-            # ✅ AMOSTRAGEM INTELIGENTE: pega até 12 cotas por admin
+            # ⚡ LIMITA PARA 12 COTAS POR ADMIN (OTIMIZAÇÃO)
             if len(cotas_validas) > 12:
-                cotas_validas = sorted(cotas_validas, key=lambda x: abs(x.get('valor_credito', 0) - credito_desejado/3))[:12]
+                # Pega as cotas mais próximas do valor desejado
+                cotas_validas.sort(key=lambda x: abs(x.get('valor_credito', 0) - credito_desejado/4))
+                cotas_validas = cotas_validas[:12]
 
-            # ✅ BUSCA COMBINAÇÕES
-            for r in range(MIN_COTAS, min(MAX_COTAS, len(cotas_validas)) + 1):
-                for i in range(0, len(cotas_validas) - r + 1):
+            # ⚡ ESTRATÉGIA 1: Combinações de 3-5 cotas (mais rápidas)
+            for r in range(3, 6):
+                if time.time() - start_time > 18:
+                    break
+                    
+                # Amostra aleatória para evitar explosão combinatória
+                for i in range(0, len(cotas_validas) - r + 1, max(1, len(cotas_validas) // 5)):
                     combinacao = cotas_validas[i:i+r]
                     
                     total_credito = sum(c.get('valor_credito', 0) for c in combinacao)
@@ -135,54 +136,91 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
 
                         resultados.append((adm, combinacao, 0))
                         
-                        if len(resultados) >= 8:
+                        if len(resultados) >= MAX_RESULTADOS:
                             break
                 
-                if len(resultados) >= 8:
+                if len(resultados) >= MAX_RESULTADOS:
                     break
+
+            # ⚡ ESTRATÉGIA 2: Combinações maiores (6-10 cotas) se necessário
+            if len(resultados) < 5 and time.time() - start_time < 15:
+                for r in range(6, min(MAX_COTAS, len(cotas_validas)) + 1):
+                    if time.time() - start_time > 18:
+                        break
+                        
+                    # Busca em blocos para ser rápido
+                    for i in range(0, min(20, len(cotas_validas) - r + 1), 2):
+                        combinacao = cotas_validas[i:i+r]
+                        
+                        total_credito = sum(c.get('valor_credito', 0) for c in combinacao)
+                        total_entrada_base = sum(c.get('valor_entrada', 0) for c in combinacao)
+                        total_entrada = total_entrada_base + (total_credito * 0.085)
+                        total_parcelas = sum(c.get('valor_parcela', 0) for c in combinacao)
+
+                        if (credito_min <= total_credito <= credito_max and
+                            entrada_min <= total_entrada <= entrada_max and
+                            parcela_min <= total_parcelas <= parcela_max):
+
+                            resultados.append((adm, combinacao, 0))
+                            
+                            if len(resultados) >= MAX_RESULTADOS:
+                                break
                     
-            if len(resultados) >= 8:
+                    if len(resultados) >= MAX_RESULTADOS:
+                        break
+
+            if len(resultados) >= MAX_RESULTADOS:
                 break
 
+        # ⚡ SE NÃO ENCONTRAR, USA ALGORITMO GANANCIOSO RÁPIDO
+        if len(resultados) < 3 and time.time() - start_time < 19:
+            resultados.extend(buscar_ganancioso_rapido(grupos, credito_min, credito_max, 
+                                                     entrada_min, entrada_max, 
+                                                     parcela_min, parcela_max))
+
         if not resultados:
-            # ✅ FALLBACK: mostra pelo menos alguma combinação
-            return gerar_resultados_fallback(credito_desejado, entrada_desejada, parcela_desejada)
+            return "🚫 Nenhuma combinação encontrada. Tente valores mais realistas."
+
+        return formatar_resultados(resultados[:10])
 
-        return formatar_resultados(resultados[:8])
-        
     except Exception as e:
         return f"❌ Erro: {str(e)}"
 
-def gerar_resultados_fallback(credito, entrada, parcela):
-    """Gera resultados de fallback quando não encontra combinações."""
-    return f"""
-🏢 **Itaú - Imóvel**
-
-### Crédito
-**R$ {credito*0.8:,.2f}**".replace(",", "v").replace(".", ",").replace("v", ".")
-
-**Entrada:** R$ {entrada*0.7:,.2f}**".replace(",", "v").replace(".", ",").replace("v", ".")
-**Prazo:** 60 meses  
-**Parcela:** R$ {parcela*0.8:,.2f}**".replace(",", "v").replace(".", ",").replace("v", ".")
-
-**Saldo Devedor:** R$ {credito*0.6:,.2f}**".replace(",", "v").replace(".", ",").replace("v", ".")
-**Taxa Mensal:** 0.75%  
-**Taxa Anual:** 9.00%  
-**Código:** G3061, P4109, G2001  
-
----
-
-### Ver mais detalhes ▼
-
-**Valor Final:** R$ {(entrada*0.7 + credito*0.6):,.2f}**".replace(",", "v").replace(".", ",").replace("v", ".")
-**Crédito Líquido:** R$ {(credito*0.8 - entrada*0.7):,.2f}**".replace(",", "v").replace(".", ",").replace("v", ".")
-**Taxa Total:** 35.42%  
-**Nº de Cotas:** 3
+def buscar_ganancioso_rapido(grupos, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max):
+    """Algoritmo ganancioso rápido para encontrar combinações."""
+    resultados = []
+    
+    for adm, cotas in grupos.items():
+        if len(cotas) < 3:
+            continue
+            
+        # Ordena por valor mais próximo da meta
+        cotas.sort(key=lambda x: abs(x.get('valor_credito', 0) - (credito_max + credito_min)/2))
+        
+        # Tenta várias combinações rápidas
+        for tentativa in range(min(10, len(cotas) // 2)):
+            combinacao = []
+            for i in range(3, 8):  # 3-7 cotas
+                if i < len(cotas):
+                    combinacao.append(cotas[i])
+                    
+                    if len(combinacao) >= 3:
+                        total_credito = sum(c.get('valor_credito', 0) for c in combinacao)
+                        total_entrada_base = sum(c.get('valor_entrada', 0) for c in combinacao)
+                        total_entrada = total_entrada_base + (total_credito * 0.085)
+                        total_parcelas = sum(c.get('valor_parcela', 0) for c in combinacao)
 
----
+                        if (credito_min <= total_credito <= credito_max and
+                            entrada_min <= total_entrada <= entrada_max and
+                            parcela_min <= total_parcelas <= parcela_max):
 
-💡 *Resultado simulado - ajuste os valores para encontrar mais combinações*
-"""
+                            resultados.append((adm, combinacao, 0))
+                            break
+            
+            if len(resultados) >= 3:
+                break
+                
+    return resultados
 
 # ✅ MODIFIQUE A FUNÇÃO PRINCIPAL PARA USAR FALLBACK
 def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):