Update app.py

app.py

@@ -85,16 +85,29 @@ 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 - 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%
+    # 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
+            # Aumenta a tolerância para valores muito altos
+            fator = min(tolerancia_max, tolerancia_base * (1 + math.log10(valor / 1000000) * 0.2))
+            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%
+
+    # Tolerâncias máximas
+    tolerancia_max_credito = 0.40  # 40%
+    tolerancia_max_entrada = 0.40  # 40%
+    tolerancia_max_parcela = 0.60  # 60%
+
+    # Calcula tolerâncias adaptativas
+    tolerancia_credito = calcular_tolerancia(credito_desejado, tolerancia_credito_base, tolerancia_credito_base, tolerancia_max_credito)
+    tolerancia_entrada = calcular_tolerancia(entrada_desejada, tolerancia_entrada_base, tolerancia_entrada_base, tolerancia_max_entrada)
+    tolerancia_parcela = calcular_tolerancia(parcela_desejada, tolerancia_parcela_base, tolerancia_parcela_base, tolerancia_max_parcela)
 
     # Define faixas de tolerância
     credito_min = credito_desejado * (1 - tolerancia_credito)
@@ -104,26 +117,36 @@ 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"🔧 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}%")
+    print(f"🔧 Tolerâncias aplicadas: Crédito: ±{tolerancia_credito*100:.1f}%, Entrada: ±{tolerancia_entrada*100:.1f}%, Parcela: ±{tolerancia_parcela*100:.1f}%")
+    print(f"🔧 Faixas: Crédito: {credito_min:,.0f} - {credito_max:,.0f}, Entrada: {entrada_min:,.0f} - {entrada_max:,.0f}, Parcela: {parcela_min:,.0f} - {parcela_max:,.0f}")
 
     resultados = []
     
     # Para cada administradora, busca combinações
     for adm, cotas in grupos_filtrados.items():
-        # Para valores altos, NÃO filtramos cotas individuais primeiro
-        # Isso permite que cotas menores sejam combinadas para atingir valores altos
-        cotas_para_combinar = cotas
+        # 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)
         
-        # Gera combinações (até 5 cotas por combinação para valores altos)
-        max_cotas_por_combinacao = 5 if credito_desejado > 1000000 else 3
+        # 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
         
-        for r in range(1, min(max_cotas_por_combinacao + 1, len(cotas_para_combinar) + 1)):
+        # Gera combinações (até 3 cotas por combinação para performance)
+        for r in range(1, min(4, len(cotas_filtradas) + 1)):
             # Limita o número de combinações testadas por administradora
-            max_combinacoes_por_adm = 100 if credito_desejado > 1000000 else 50
+            max_combinacoes_por_adm = 50
             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
                     
@@ -132,7 +155,6 @@ 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):
@@ -145,76 +167,7 @@ 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 * 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:
+                    if len(resultados) >= max_combinacoes * 3:  # Coleta mais para depois filtrar as melhores
                         break
             
             if len(resultados) >= max_combinacoes * 3:
@@ -226,6 +179,7 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
     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])