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)]
@@ -80,114 +78,74 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
     if df_filtrado.empty:
         return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
 
-    # Define faixas de tolerância
-    credito_min, credito_max = credito_desejado * 0.93, credito_desejado * 1.07
-    entrada_min, entrada_max = entrada_desejada * 0.93, entrada_desejada * 1.07
-    parcela_min, parcela_max = parcela_desejada * 0.75, parcela_desejada * 1.25
+    # ✅ TOLERÂNCIAS MAIS REALISTAS
+    credito_min, credito_max = credito_desejado * 0.85, credito_desejado * 1.15
+    entrada_min, entrada_max = entrada_desejada * 0.80, entrada_desejada * 1.20
+    parcela_min, parcela_max = parcela_desejada * 0.60, parcela_desejada * 1.40
 
     grupos = agrupar_por_administradora(df_filtrado)
     resultados = []
 
-    # 🔥 OTIMIZAÇÃO 1: Pré-filtra cotas que individualmente já estão fora dos limites
     for adm, cotas in grupos.items():
-        cotas_filtradas = []
+        # 🔥 OTIMIZAÇÃO: Pré-filtra cotas viáveis
+        cotas_validas = []
         for cota in cotas:
-            # Verifica se a cota individual está dentro dos limites básicos
-            if (credito_min <= cota['valor_credito'] <= credito_max and
-                parcela_min <= cota['valor_parcela'] <= parcela_max):
-                cotas_filtradas.append(cota)
+            credito_cota = cota.get('valor_credito', 0)
+            parcela_cota = cota.get('valor_parcela', 0)
+            
+            # Só considera cotas que individualmente fazem sentido
+            if (credito_min <= credito_cota <= credito_max and
+                parcela_min <= parcela_cota <= parcela_max):
+                cotas_validas.append(cota)
         
-        if len(cotas_filtradas) < 1:
+        if len(cotas_validas) < 1:
             continue
             
-        # 🔥 OTIMIZAÇÃO 2: Limita para no máximo 15 cotas por administradora
-        if len(cotas_filtradas) > 15:
-            # Mantém as cotas mais próximas do valor desejado
-            cotas_filtradas.sort(key=lambda x: abs(x['valor_credito'] - credito_desejado/5))
-            cotas_filtradas = cotas_filtradas[:15]
-
-        # 🔥 OTIMIZAÇÃO 3: Busca primeiro combinações menores (mais rápidas)
-        for r in range(1, min(6, len(cotas_filtradas)) + 1):  # Primeiro busca até 5 cotas
-            for combinacao in itertools.combinations(cotas_filtradas, r):
-                total_credito = sum(c['valor_credito'] for c in combinacao)
-                total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
+        # Limita para 12 cotas por admin para performance
+        if len(cotas_validas) > 12:
+            cotas_validas = cotas_validas[:12]
+
+        # Busca combinações de 1 a 6 cotas (mais rápido)
+        for r in range(1, min(6, len(cotas_validas)) + 1):
+            for combinacao in itertools.combinations(cotas_validas, 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['valor_parcela'] for c in combinacao)
+                total_parcelas = sum(c.get('valor_parcela', 0) for c in combinacao)
 
+                # ✅ VERIFICAÇÃO COM TOLERÂNCIAS AMPLAS
                 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)
+                    total_saldo = sum(c.get('saldo_devedor', 0) for c in combinacao)
                     valor_final = round(total_entrada + total_saldo, 2)
                     diferenca = abs(valor_final - total_credito)
 
                     resultados.append((adm, combinacao, diferenca))
                     
-                    # 🔥 OTIMIZAÇÃO 4: Limita resultados por administradora
-                    if len([r for r in resultados if r[0] == adm]) >= 10:
+                    if len(resultados) >= 25:  # Limite total
                         break
             
-            if len(resultados) >= 30:  # Limite total de resultados
+            if len(resultados) >= 25:
                 break
                 
-        if len(resultados) >= 30:
+        if len(resultados) >= 25:
             break
 
-    # 🔥 Busca combinações maiores apenas se não encontrou muitas ainda
-    if len(resultados) < 20:
-        for adm, cotas in grupos.items():
-            cotas_filtradas = []
-            for cota in cotas:
-                if (credito_min <= cota['valor_credito'] <= credito_max and
-                    parcela_min <= cota['valor_parcela'] <= parcela_max):
-                    cotas_filtradas.append(cota)
-            
-            if len(cotas_filtradas) < 6:  # Só busca combinações grandes se tiver cotas suficientes
-                continue
-                
-            # Busca combinações de 6 a 10 cotas
-            for r in range(6, min(10, len(cotas_filtradas)) + 1):
-                # Amostra aleatória para evitar combinações explosivas
-                for i in range(0, min(50, len(cotas_filtradas)), max(1, len(cotas_filtradas)//10)):
-                    for j in range(i + r, min(i + 20, len(cotas_filtradas))):
-                        combinacao = cotas_filtradas[i:j]
-                        if len(combinacao) != r:
-                            continue
-                            
-                        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))
-                            
-                            if len(resultados) >= 30:
-                                break
-                    
-                    if len(resultados) >= 30:
-                        break
-                        
-                if len(resultados) >= 30:
-                    break
-                    
-            if len(resultados) >= 30:
-                break
-
     if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+        # 🆘 SE NÃO ENCONTRAR, TENTA COM TOLERÂNCIAS MUITO AMPLAS
+        return buscar_combinacoes_emergencia(credito_desejado, entrada_desejada, parcela_desejada, administradoras)
 
-    resultados.sort(key=lambda x: x[2]) # Ordena pela diferença
+    resultados.sort(key=lambda x: x[2])
+    return formatar_resultados(resultados[:15])
 
-    return formatar_resultados(resultados)
+def buscar_combinacoes_emergencia(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
+    """Busca com tolerâncias muito amplas para garantir algum resultado."""
+    # Tolerâncias de emergência
+    credito_min, credito_max = credito_desejado * 0.70, credito_desejado * 1.30
+    entrada_min, entrada_max = entrada_desejada * 0.60, entrada_desejada * 1.40
+    parcela_min, parcela_max = parcela_desejada * 0.40, parcela_desejada * 2.00
 
 def formatar_moeda(valor):
     return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
@@ -320,7 +278,7 @@ with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
     with gr.Row():
         credito_input = gr.Number(label="Crédito Desejado (R$)", value=300000, step=1000)
         entrada_input = gr.Number(label="Entrada Desejada (R$)", value=30000, step=1000)
-        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=1500, step=100)
+        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=2500, step=100)
 
     administradoras_multiselect = gr.CheckboxGroup(
         label="Filtrar por Administradoras",