Update app.py

app.py

@@ -61,99 +61,179 @@ 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 dentro dos parâmetros especificados."""
-    # Garante que o DataFrame está carregado
+def buscar_combinacoes_rapido(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
+    """Busca combinações de forma extremamente rápida com algoritmo inteligente."""
     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."
+            return "❌ Erro: Planilha não carregada."
 
-    # Filtra por tipo de bem e administradoras
+    # Filtra as cotas
     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)]
 
     if df_filtrado.empty:
-        return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
+        return "🚫 Nenhuma cota encontrada com os filtros aplicados."
 
-    # 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 amplas para melhor diversificação
+    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 = []
     
-    # Configuração: mínimo 3 cotas, máximo 10 cotas por combinação
     MIN_COTAS = 3
     MAX_COTAS = 10
+    MAX_RESULTADOS_POR_ADM = 30
+    TOTAL_MAX_RESULTADOS = 100
 
     for adm, cotas in grupos.items():
-        # Filtra cotas que já estão dentro dos limites individualmente
-        cotas_filtradas = [
-            c for c in cotas 
-            if (credito_min <= c['valor_credito'] <= credito_max and
-                parcela_min <= c['valor_parcela'] <= parcela_max)
-        ]
-        
-        # Só busca se tiver pelo menos MIN_COTAS cotas
-        if len(cotas_filtradas) < MIN_COTAS:
+        if len(cotas) < MIN_COTAS:
             continue
             
-        # Busca combinações de MIN_COTAS a MAX_COTAS cotas
-        for r in range(MIN_COTAS, min(MAX_COTAS, len(cotas_filtradas)) + 1):
-            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)
-                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 dos limites
-                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))
-                    
-                    # Limita o número de resultados por administradora para evitar explosão
-                    if len(resultados) >= 1000:  # Safety limit
-                        break
-            if len(resultados) >= 1000:
+        # Ordena cotas por proximidade do valor desejado (otimização)
+        cotas_ordenadas = sorted(cotas, key=lambda x: abs(x['valor_credito'] - credito_desejado/MAX_COTAS))
+        
+        # Busca usando algoritmo ganancioso com backtracking limitado
+        encontrados = buscar_combinacoes_inteligente(
+            cotas_ordenadas, credito_min, credito_max, entrada_min, 
+            entrada_max, parcela_min, parcela_max, MIN_COTAS, MAX_COTAS,
+            max_resultados=MAX_RESULTADOS_POR_ADM
+        )
+        
+        for combo in encontrados:
+            total_credito = sum(c['valor_credito'] for c in combo)
+            total_entrada_base = sum(c['valor_entrada'] for c in combo)
+            total_entrada = total_entrada_base + (total_credito * 0.085)
+            total_saldo = sum(c['saldo_devedor'] for c in combo)
+            valor_final = round(total_entrada + total_saldo, 2)
+            diferenca = abs(valor_final - total_credito)
+            
+            resultados.append((adm, combo, diferenca))
+            
+            if len(resultados) >= TOTAL_MAX_RESULTADOS:
                 break
+                
+        if len(resultados) >= TOTAL_MAX_RESULTADOS:
+            break
 
     if not resultados:
-        # Tenta buscar com tolerâncias mais amplas se não encontrar resultados
-        return buscar_combinacoes_com_tolerancia_ampliada(
-            credito_desejado, entrada_desejada, parcela_desejada, administradoras
-        )
-
-    resultados.sort(key=lambda x: x[2]) # Ordena pela diferença
+        return "🚫 Nenhuma combinação adequada encontrada. Tente ampliar os filtros."
 
-    return formatar_resultados(resultados)
+    # Ordena por melhor match
+    resultados.sort(key=lambda x: x[2])
+    
+    return formatar_resultados(resultados[:20])
 
-def buscar_combinacoes_com_tolerancia_ampliada(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
-    """Busca combinações com tolerâncias mais amplas quando não encontra resultados."""
-    # Tolerâncias ampliadas
-    credito_min, credito_max = credito_desejado * 0.85, credito_desejado * 1.15
-    entrada_min, entrada_max = entrada_desejada * 0.85, entrada_desejada * 1.15
-    parcela_min, parcela_max = parcela_desejada * 0.65, parcela_desejada * 1.35
+def buscar_combinacoes_inteligente(cotas, credito_min, credito_max, entrada_min, 
+                                 entrada_max, parcela_min, parcela_max, 
+                                 min_cotas, max_cotas, max_resultados=30):
+    """Algoritmo inteligente para encontrar combinações rapidamente."""
+    resultados = []
+    n = len(cotas)
+    
+    # Pré-calcula arrays para performance
+    creditos = np.array([c['valor_credito'] for c in cotas])
+    entradas = np.array([c['valor_entrada'] for c in cotas])
+    parcelas = np.array([c['valor_parcela'] for c in cotas])
+    saldos = np.array([c['saldo_devedor'] for c in cotas])
+    
+    # Função de avaliação rápida
+    def avalia_combinacao(indices):
+        total_credito = creditos[indices].sum()
+        total_entrada_base = entradas[indices].sum()
+        total_entrada = total_entrada_base + (total_credito * 0.085)
+        total_parcelas = parcelas[indices].sum()
+        
+        return (credito_min <= total_credito <= credito_max and
+                entrada_min <= total_entrada <= entrada_max and
+                parcela_min <= total_parcelas <= parcela_max)
+    
+    # Estratégia 1: Combinações de tamanho fixo (3-6 cotas) - mais rápido
+    for tamanho in range(min_cotas, min(7, max_cotas + 1)):
+        if len(resultados) >= max_resultados:
+            break
+            
+        # Amostra aleatória de combinações para evitar explosão combinatória
+        indices = list(range(n))
+        np.random.shuffle(indices)  # Embaralha para diversidade
+        
+        # Testa um número limitado de combinações
+        for combo_indices in islice(combinations(indices, tamanho), 1000):
+            if avalia_combinacao(combo_indices):
+                combo = [cotas[i] for i in combo_indices]
+                resultados.append(combo)
+                
+                if len(resultados) >= max_resultados:
+                    break
+    
+    # Estratégia 2: Para combinações maiores (7-10 cotas), usa algoritmo ganancioso
+    if len(resultados) < max_resultados and max_cotas >= 7:
+        for _ in range(min(50, max_resultados - len(resultados))):
+            combo = []
+            indices_usados = set()
+            
+            # Adiciona cotas até atingir o objetivo
+            for tentativa in range(max_cotas):
+                melhor_idx = None
+                melhor_score = float('inf')
+                
+                # Encontra a melhor cota para adicionar
+                for idx in range(n):
+                    if idx in indices_usados:
+                        continue
+                        
+                    combo_teste = combo + [cotas[idx]]
+                    indices_teste = list(indices_usados) + [idx]
+                    
+                    total_credito = sum(c['valor_credito'] for c in combo_teste)
+                    score = abs(total_credito - (credito_max + credito_min)/2)
+                    
+                    if score < melhor_score:
+                        melhor_score = score
+                        melhor_idx = idx
+                
+                if melhor_idx is not None:
+                    combo.append(cotas[melhor_idx])
+                    indices_usados.add(melhor_idx)
+                    
+                    # Verifica se a combinação atual é válida
+                    if len(combo) >= min_cotas and avalia_combinacao(list(indices_usados)):
+                        resultados.append(combo.copy())
+                        if len(resultados) >= max_resultados:
+                            break
+            
+            if len(resultados) >= max_resultados:
+                break
+    
+    return resultados[:max_resultados]
 
-def formatar_moeda(valor):
-    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+# Função principal ajustada
+def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
+    entrada_calculada = credito_desejado * 0.085 + entrada_desejada
+    
+    start_time = time.time()
+    resultado = buscar_combinacoes_rapido(
+        credito_desejado, entrada_calculada, parcela_desejada, administradoras
+    )
+    
+    elapsed = time.time() - start_time
+    print(f"⏱️ Busca concluída em {elapsed:.2f} segundos")
+    
+    return resultado
 
+# Atualize a interface para mostrar estatísticas
 def formatar_resultados(resultados):
-    """Formata os resultados para exibição."""
-    resposta = ""
-    # Limita a 15 resultados para evitar saídas muito longas
-    for idx, (adm, combinacao, _) in enumerate(resultados[:15], 1):
+    """Formata os resultados com informações de diversificação."""
+    if not resultados:
+        return "🚫 Nenhuma combinação encontrada."
+    
+    resposta = f"📊 **Encontradas {len(resultados)} combinações**\n\n"
+    
+    for idx, (adm, combinacao, diferenca) in enumerate(resultados, 1):
         codigos = [str(c.get('codigo', 'N/A')) for c in combinacao]
         total_credito = sum(c['valor_credito'] for c in combinacao)
         total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -169,7 +249,7 @@ def formatar_resultados(resultados):
         taxa_mensal = taxa_percentual / maior_prazo if maior_prazo > 0 else 0
 
         resposta += f"""
---- COMBINAÇÃO {idx} ---
+--- COMBINAÇÃO {idx} ({len(combinacao)} cotas) ---
 🏢 Administradora: {adm}
 🔢 Códigos: {', '.join(codigos)}
 💰 Crédito Total: {formatar_moeda(total_credito)}