Update app.py

app.py

@@ -1,10 +1,4 @@
-"""Imovel.ipynb
-Automatically generated by Colab.
-Original file is located at
-    https://colab.research.google.com/drive/1DZAQZfrXvTy358Vg2qfUg_ge6b3kcgBy
-"""
-
-# app.py OTIMIZADO
+# app.py - VERSÃO CORRIGIDA E OTIMIZADA
 import pandas as pd
 import requests
 import io
@@ -22,10 +16,16 @@ URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 df = None
 df_imovel = None
 grupos_imovel = None
+planilha_carregada = False
 
 def carregar_planilha():
     """Carrega e prepara a planilha para análise."""
-    global df, df_imovel, grupos_imovel
+    global df, df_imovel, grupos_imovel, planilha_carregada
+    
+    # Se já carregou, não precisa carregar novamente
+    if planilha_carregada:
+        return True
+        
     try:
         print("⏳ Carregando planilha...")
         response = requests.get(URL)
@@ -53,7 +53,10 @@ def carregar_planilha():
         df_imovel = df[df['tipo_do_bem'].str.lower() == 'imovel'].copy()
         grupos_imovel = agrupar_por_administradora(df_imovel)
 
+        planilha_carregada = True
         print("✅ Planilha carregada e pré-processada com sucesso")
+        print(f"✅ Total de cotas de imóvel: {len(df_imovel)}")
+        print(f"✅ Administradoras disponíveis: {list(grupos_imovel.keys())}")
         return True
 
     except Exception as e:
@@ -77,37 +80,30 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
             return "❌ Erro: Planilha não carregada. Por favor, tente novamente."
 
     # Filtra administradoras se especificado
-    if administradoras:
+    if administradoras and len(administradoras) > 0:
         grupos_filtrados = {adm: cotas for adm, cotas in grupos_imovel.items() if adm in administradoras}
+        print(f"🔍 Filtrando por administradoras: {administradoras}")
     else:
         grupos_filtrados = grupos_imovel
+        print("🔍 Buscando em todas as administradoras")
 
     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
-            # 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)
+    print(f"🔍 Total de administradoras no filtro: {len(grupos_filtrados)}")
+    
+    # TOLERÂNCIAS - Ajustadas para valores altos
+    # Para valores muito altos, aumentamos as tolerâncias
+    if credito_desejado > 5000000:  # Para valores acima de 5 milhões
+        tolerancia_credito = 0.15  # 15%
+        tolerancia_entrada = 0.15  # 15%
+        tolerancia_parcela = 0.40  # 40%
+        max_cotas_combinacao = 6  # Até 6 cotas por combinação
+    else:
+        tolerancia_credito = 0.10  # 10%
+        tolerancia_entrada = 0.10  # 10%
+        tolerancia_parcela = 0.30  # 30%
+        max_cotas_combinacao = 4  # Até 4 cotas por combinação
 
     # Define faixas de tolerância
     credito_min = credito_desejado * (1 - tolerancia_credito)
@@ -117,44 +113,43 @@ 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"🔧 Faixas: Crédito: {credito_min:,.0f} - {credito_max:,.0f}, Entrada: {entrada_min:,.0f} - {entrada_max:,.0f}, Parcela: {parcela_min:,.0f} - {parcela_max:,.0f}")
+    print(f"💰 Valores desejados: Crédito: R$ {credito_desejado:,.2f}, Entrada: R$ {entrada_desejada:,.2f}, Parcela: R$ {parcela_desejada:,.2f}")
+    print(f"🔧 Tolerâncias: Crédito: ±{tolerancia_credito*100:.1f}%, Entrada: ±{tolerancia_entrada*100:.1f}%, Parcela: ±{tolerancia_parcela*100:.1f}%")
+    print(f"🔧 Faixas aceitáveis: Crédito: R$ {credito_min:,.2f} - R$ {credito_max:,.2f}")
+    print(f"🔧 Faixas aceitáveis: Entrada: R$ {entrada_min:,.2f} - R$ {entrada_max:,.2f}")
+    print(f"🔧 Faixas aceitáveis: Parcela: R$ {parcela_min:,.2f} - R$ {parcela_max:,.2f}")
+    print(f"🔧 Máximo de cotas por combinação: {max_cotas_combinacao}")
 
     resultados = []
+    total_combinacoes_testadas = 0
     
     # 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)
+        print(f"🔍 Analisando administradora: {adm} ({len(cotas)} 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
+        # Para valores altos, NÃO filtramos cotas individuais primeiro
+        # Isso permite que cotas menores sejam combinadas para atingir valores altos
+        cotas_para_combinar = cotas
         
-        # Gera combinações (até 3 cotas por combinação para performance)
-        for r in range(1, min(4, len(cotas_filtradas) + 1)):
+        # Gera combinações
+        for r in range(1, min(max_cotas_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 = 200 if credito_desejado > 5000000 else 100
             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
                     
+                total_combinacoes_testadas += 1
+                combinacoes_geradas += 1
+                
                 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 das tolerâncias
                 if (credito_min <= total_credito <= credito_max and
                     entrada_min <= total_entrada <= entrada_max and
                     parcela_min <= total_parcelas <= parcela_max):
@@ -164,10 +159,9 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
                     diferenca = abs(valor_final - total_credito)
 
                     resultados.append((adm, combinacao, diferenca))
-                    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 * 3:
                         break
             
             if len(resultados) >= max_combinacoes * 3:
@@ -176,13 +170,101 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
         if len(resultados) >= max_combinacoes * 3:
             break
 
+    print(f"🔍 Total de combinações testadas: {total_combinacoes_testadas}")
+    print(f"🔍 Combinações válidas encontradas: {len(resultados)}")
+
     if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+        # Tenta uma busca mais ampla se não encontrou resultados
+        print("🔍 Nenhuma combinação encontrada. Tentando busca ampla...")
+        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 and len(administradoras) > 0:
+        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
+    if credito_desejado > 5000000:
+        tolerancia_credito = 0.25  # 25%
+        tolerancia_entrada = 0.25  # 25%
+        tolerancia_parcela = 0.60  # 60%
+        max_cotas_combinacao = 8  # Até 8 cotas por combinação
+    else:
+        tolerancia_credito = 0.20  # 20%
+        tolerancia_entrada = 0.20  # 20%
+        tolerancia_parcela = 0.50  # 50%
+        max_cotas_combinacao = 6  # Até 6 cotas por combinação
+
+    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}%")
+    print(f"🔍 BUSCA AMPLA: Máximo de cotas por combinação: {max_cotas_combinacao}")
+
+    resultados = []
+    total_combinacoes_testadas = 0
+    
+    for adm, cotas in grupos_filtrados.items():
+        print(f"🔍 BUSCA AMPLA - Analisando administradora: {adm}")
+        
+        # Gera combinações
+        for r in range(1, min(max_cotas_combinacao + 1, len(cotas) + 1)):
+            combinacoes_geradas = 0
+            max_combinacoes_por_adm = 300
+            
+            for combinacao in itertools.combinations(cotas, r):
+                if combinacoes_geradas >= max_combinacoes_por_adm:
+                    break
+                    
+                total_combinacoes_testadas += 1
+                combinacoes_geradas += 1
+                
+                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) >= max_combinacoes * 2:
+                        break
+            
+            if len(resultados) >= max_combinacoes * 2:
+                break
+        
+        if len(resultados) >= max_combinacoes * 2:
+            break
+
+    print(f"🔍 BUSCA AMPLA: Total de combinações testadas: {total_combinacoes_testadas}")
+    print(f"🔍 BUSCA AMPLA: Combinações válidas encontradas: {len(resultados)}")
+
+    if not resultados:
+        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+
+    resultados.sort(key=lambda x: x[2])
+    return formatar_resultados(resultados[:max_combinacoes])
+
 def formatar_moeda(valor):
     return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
 
@@ -210,7 +292,7 @@ def formatar_resultados(resultados):
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
 🏢 Administradora: {adm}
-🔢 Códigos: {', '.join(codigos)}
+🔢 Códigos: {', '.join(codigos)} ({len(combinacao)} cotas)
 💰 Crédito Total: {formatar_moeda(total_credito)}
 💵 Entrada (+comissão): {formatar_moeda(total_entrada)}
 📉 Saldo Devedor: {formatar_moeda(total_saldo)}
@@ -233,7 +315,7 @@ def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, admin
 
 # Prepara a lista de administradoras para o Gradio
 def get_administradoras_options():
-    if df is not None:
+    if df is not None and planilha_carregada:
         adm_list = df[df['tipo_do_bem'].str.lower() == 'imovel']['administradora'].unique()
         return sorted(adm_list)
     return []