Update app.py

app.py

@@ -85,24 +85,16 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
     if not grupos_filtrados:
         return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
 
-    # TOLERÂNCIAS ADAPTATIVAS - Ajusta com base no valor
-    # Para valores altos, aumenta a tolerância percentual
-    def calcular_tolerancia(valor, tolerancia_base, tolerancia_min, tolerancia_max):
-        if valor > 1000000:  # Para valores acima de 1 milhão
-            # Reduz gradualmente a tolerância percentual conforme o valor aumenta
-            fator = max(tolerancia_min, min(tolerancia_max, tolerancia_base * (1000000 / valor)**0.5))
-            return fator
-        return tolerancia_base
-
-    # Tolerâncias base
-    tolerancia_credito_base = 0.10  # 10%
-    tolerancia_entrada_base = 0.10  # 10%
-    tolerancia_parcela_base = 0.30  # 30%
-
-    # Calcula tolerâncias adaptativas
-    tolerancia_credito = calcular_tolerancia(credito_desejado, tolerancia_credito_base, 0.15, 0.25)
-    tolerancia_entrada = calcular_tolerancia(entrada_desejada, tolerancia_entrada_base, 0.15, 0.25)
-    tolerancia_parcela = calcular_tolerancia(parcela_desejada, tolerancia_parcela_base, 0.40, 0.50)
+    # TOLERÂNCIAS - Ajustadas para valores altos
+    # Para valores altos, focamos em combinações de múltiplas cotas
+    if credito_desejado > 1000000:  # Para valores acima de 1 milhão
+        tolerancia_credito = 0.10  # 10%
+        tolerancia_entrada = 0.10  # 10%
+        tolerancia_parcela = 0.30  # 30%
+    else:
+        tolerancia_credito = 0.10  # 10%
+        tolerancia_entrada = 0.10  # 10%
+        tolerancia_parcela = 0.30  # 30%
 
     # Define faixas de tolerância
     credito_min = credito_desejado * (1 - tolerancia_credito)
@@ -112,35 +104,26 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
     parcela_min = parcela_desejada * (1 - tolerancia_parcela)
     parcela_max = parcela_desejada * (1 + tolerancia_parcela)
 
-    print(f"🔧 Tolerâncias aplicadas: Crédito: ±{tolerancia_credito*100:.1f}%, Entrada: ±{tolerancia_entrada*100:.1f}%, Parcela: ±{tolerancia_parcela*100:.1f}%")
+    print(f"🔧 Buscando combinações para: Crédito: {credito_desejado:,.0f}, Entrada: {entrada_desejada:,.0f}, Parcela: {parcela_desejada:,.0f}")
+    print(f"🔧 Tolerâncias: Crédito: ±{tolerancia_credito*100:.1f}%, Entrada: ±{tolerancia_entrada*100:.1f}%, Parcela: ±{tolerancia_parcela*100:.1f}%")
 
     resultados = []
     
     # Para cada administradora, busca combinações
     for adm, cotas in grupos_filtrados.items():
-        # Pré-filtra cotas que individualmente estão dentro das faixas de tolerância
-        cotas_filtradas = []
-        for cota in cotas:
-            cota_credito = cota['valor_credito']
-            cota_entrada = cota['valor_entrada'] + (cota_credito * 0.085)
-            cota_parcela = cota['valor_parcela']
-            
-            if (credito_min <= cota_credito <= credito_max and
-                entrada_min <= cota_entrada <= entrada_max and
-                parcela_min <= cota_parcela <= parcela_max):
-                cotas_filtradas.append(cota)
+        # Para valores altos, NÃO filtramos cotas individuais primeiro
+        # Isso permite que cotas menores sejam combinadas para atingir valores altos
+        cotas_para_combinar = cotas
         
-        # Se não há cotas individuais dentro da tolerância, tenta combinações
-        if not cotas_filtradas:
-            cotas_filtradas = cotas  # Usa todas as cotas para combinações
+        # Gera combinações (até 5 cotas por combinação para valores altos)
+        max_cotas_por_combinacao = 5 if credito_desejado > 1000000 else 3
         
-        # Gera combinações (até 3 cotas por combinação para performance)
-        for r in range(1, min(4, len(cotas_filtradas) + 1)):
+        for r in range(1, min(max_cotas_por_combinacao + 1, len(cotas_para_combinar) + 1)):
             # Limita o número de combinações testadas por administradora
-            max_combinacoes_por_adm = 50
+            max_combinacoes_por_adm = 100 if credito_desejado > 1000000 else 50
             combinacoes_geradas = 0
             
-            for combinacao in itertools.combinations(cotas_filtradas, r):
+            for combinacao in itertools.combinations(cotas_para_combinar, r):
                 if combinacoes_geradas >= max_combinacoes_por_adm:
                     break
                     
@@ -149,6 +132,7 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
                 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):
@@ -161,7 +145,76 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
                     combinacoes_geradas += 1
                     
                     # Para se já encontrou combinações suficientes
-                    if len(resultados) >= max_combinacoes * 3:  # Coleta mais para depois filtrar as melhores
+                    if len(resultados) >= max_combinacoes * 5:  # Coleta mais para depois filtrar as melhores
+                        break
+            
+            if len(resultados) >= max_combinacoes * 5:
+                break
+        
+        if len(resultados) >= max_combinacoes * 5:
+            break
+
+    if not resultados:
+        # Tenta uma busca mais ampla se não encontrou resultados
+        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=10):
+    """Busca combinações com tolerâncias mais amplas para valores altos."""
+    global grupos_imovel
+    
+    # Filtra administradoras se especificado
+    if administradoras:
+        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
+    tolerancia_credito = 0.20  # 20%
+    tolerancia_entrada = 0.20  # 20%
+    tolerancia_parcela = 0.50  # 50%
+
+    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)
+
+    print(f"🔧 Busca ampla: Tolerâncias: Crédito: ±{tolerancia_credito*100:.1f}%, Entrada: ±{tolerancia_entrada*100:.1f}%, Parcela: ±{tolerancia_parcela*100:.1f}%")
+
+    resultados = []
+    
+    for adm, cotas in grupos_filtrados.items():
+        # Gera combinações (até 6 cotas por combinação)
+        for r in range(1, min(7, len(cotas) + 1)):
+            combinacoes_geradas = 0
+            max_combinacoes_por_adm = 150
+            
+            for combinacao in itertools.combinations(cotas, r):
+                if combinacoes_geradas >= max_combinacoes_por_adm:
+                    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)
+                total_parcelas = sum(c['valor_parcela'] 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):
+
+                    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))
+                    combinacoes_geradas += 1
+                    
+                    if len(resultados) >= max_combinacoes * 3:
                         break
             
             if len(resultados) >= max_combinacoes * 3:
@@ -173,7 +226,6 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
     if not resultados:
         return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
 
-    # Ordena pela diferença e pega as melhores
     resultados.sort(key=lambda x: x[2])
     return formatar_resultados(resultados[:max_combinacoes])