Update app.py

app.py

@@ -62,8 +62,8 @@ def agrupar_por_administradora(dataframe):
         grupos[row['administradora']].append(row.to_dict())
     return grupos
 
-def buscar_combinacoes_rapido(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de forma extremamente rápida com algoritmo inteligente."""
+def buscar_combinacoes_eficiente(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
+    """Busca combinações de forma eficiente e garantida."""
     if df is None:
         if not carregar_planilha():
             return "❌ Erro: Planilha não carregada."
@@ -78,161 +78,91 @@ def buscar_combinacoes_rapido(credito_desejado, entrada_desejada, parcela_deseja
     if df_filtrado.empty:
         return "🚫 Nenhuma cota encontrada com os filtros aplicados."
 
-    # 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
+    # Tolerâncias amplas para garantir resultados
+    credito_min, credito_max = credito_desejado * 0.80, credito_desejado * 1.20
+    entrada_min, entrada_max = entrada_desejada * 0.75, entrada_desejada * 1.25
+    parcela_min, parcela_max = parcela_desejada * 0.50, parcela_desejada * 1.50
 
     grupos = agrupar_por_administradora(df_filtrado)
     resultados = []
     
     MIN_COTAS = 3
     MAX_COTAS = 10
-    MAX_RESULTADOS_POR_ADM = 30
-    TOTAL_MAX_RESULTADOS = 100
 
     for adm, cotas in grupos.items():
         if len(cotas) < MIN_COTAS:
             continue
             
-        # Ordena cotas por proximidade do valor desejado (otimização)
-        cotas_ordenadas = sorted(cotas, key=lambda x: abs(x['valor_credito'] - credito_desejado/MAX_COTAS))
+        # Ordena por valor de crédito (otimização)
+        cotas_ordenadas = sorted(cotas, key=lambda x: x['valor_credito'])
         
-        # 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
+        # Busca combinações de forma inteligente
+        for tamanho in range(MIN_COTAS, min(MAX_COTAS + 1, len(cotas_ordenadas) + 1)):
+            # Usa amostragem para evitar explosão combinatória
+            for i in range(0, len(cotas_ordenadas), max(1, len(cotas_ordenadas) // 10)):
+                for j in range(i + tamanho, min(i + 50, len(cotas_ordenadas))):
+                    combinacao = cotas_ordenadas[i:j]
+                    if len(combinacao) != tamanho:
+                        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))
+                        
+                        # Limita resultados por administradora
+                        if len(resultados) >= 50:
+                            break
                 
-        if len(resultados) >= TOTAL_MAX_RESULTADOS:
-            break
+                if len(resultados) >= 50:
+                    break
+                    
+            if len(resultados) >= 50:
+                break
 
     if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada. Tente ampliar os filtros."
+        return "🚫 Nenhuma combinação adequada encontrada. Tente ampliar os filtros ou ajustar os valores."
 
     # Ordena por melhor match
     resultados.sort(key=lambda x: x[2])
     
-    return formatar_resultados(resultados[:20])
+    return formatar_resultados(resultados[:15])
 
-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()
+# Substitua a função de busca
+def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
+    try:
+        entrada_calculada = credito_desejado * 0.085 + entrada_desejada
         
-        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
+        start_time = time.time()
+        resultado = buscar_combinacoes_eficiente(
+            credito_desejado, entrada_calculada, parcela_desejada, administradoras
+        )
         
-        # 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]
-
-# 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
+        elapsed = time.time() - start_time
+        print(f"✅ Busca concluída em {elapsed:.2f} segundos")
+        
+        return resultado
+        
+    except Exception as e:
+        return f"❌ Erro durante a busca: {str(e)}"
 
-# Atualize a interface para mostrar estatísticas
+# Função de formatação atualizada
 def formatar_resultados(resultados):
-    """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"
+    """Formata os resultados para exibição."""
+    if not resultados or isinstance(resultados, str):
+        return resultados
+        
+    resposta = f"🎯 **{len(resultados)} combinações encontradas**\n\n"
     
     for idx, (adm, combinacao, diferenca) in enumerate(resultados, 1):
         codigos = [str(c.get('codigo', 'N/A')) for c in combinacao]
@@ -250,19 +180,19 @@ def formatar_resultados(resultados):
         taxa_mensal = taxa_percentual / maior_prazo if maior_prazo > 0 else 0
 
         resposta += f"""
---- COMBINAÇÃO {idx} ({len(combinacao)} cotas) ---
+--- COMBINAÇÃO {idx} ({len(combinacao)} COTAS) ---
 🏢 Administradora: {adm}
 🔢 Códigos: {', '.join(codigos)}
 💰 Crédito Total: {formatar_moeda(total_credito)}
-💵 Entrada (+comissão): {formatar_moeda(total_entrada)}
+💵 Entrada (+8.5%): {formatar_moeda(total_entrada)}
 📉 Saldo Devedor: {formatar_moeda(total_saldo)}
-💲 Parcela: {formatar_moeda(total_parcelas)}
-⏳ Prazo: {maior_prazo} meses
+💲 Parcela Total: {formatar_moeda(total_parcelas)}
+⏳ Maior Prazo: {maior_prazo} meses
 🔚 Valor Final: {formatar_moeda(valor_final)}
 💠 Crédito Líquido: {formatar_moeda(credito_real)}
-📊 Taxa Total: {taxa_percentual:.2f}% ({formatar_moeda(taxa_total)})
+📊 Taxa Total: {taxa_percentual:.2f}%
 🗓️ Taxa Mensal: {taxa_mensal:.2f}%
-🗓️ Taxa Anual: {taxa_mensal * 12:.2f}%
+📈 Taxa Anual: {taxa_mensal * 12:.2f}%
 """
     return resposta