Update app.py

app.py

@@ -1,3 +1,10 @@
+"""Imovel.ipynb
+Automatically generated by Colab.
+Original file is located at
+    https://colab.research.google.com/drive/1DZAQZfrXvTy358Vg2qfUg_ge6b3kcgBy
+"""
+
+# app.py
 import pandas as pd
 import requests
 import io
@@ -5,9 +12,9 @@ import itertools
 from collections import defaultdict
 import gradio as gr
 import time
-import random
 
 # 🔧 CONFIGURAÇÕES GLOBAIS
+# Certifique-se de que este FILE_ID esteja acessível publicamente ou para "Qualquer pessoa com o link"
 FILE_ID = "1XvNz7DlWioT64uNdcfBSL8Ui2nRSi9gT"
 URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 
@@ -19,7 +26,7 @@ def carregar_planilha():
     global df
     try:
         print("⏳ Carregando planilha...")
-        response = requests.get(URL, timeout=30)
+        response = requests.get(URL)
         response.raise_for_status()
         data = io.BytesIO(response.content)
         df = pd.read_excel(data)
@@ -34,10 +41,8 @@ def carregar_planilha():
                 df[coluna] = pd.to_numeric(df[coluna], errors='coerce').fillna(0)
 
         # Verifica colunas essenciais
-        colunas_necessarias = ['tipo_do_bem', 'administradora', 'valor_credito', 'valor_entrada', 'valor_parcela']
-        for coluna in colunas_necessarias:
-            if coluna not in df.columns:
-                raise ValueError(f"Coluna essencial não encontrada: {coluna}")
+        if 'tipo_do_bem' not in df.columns or 'administradora' not in df.columns:
+            raise ValueError("Colunas essenciais não encontradas")
 
         # Remove duplicatas
         df.drop_duplicates(inplace=True)
@@ -56,183 +61,66 @@ def agrupar_por_administradora(dataframe):
         grupos[row['administradora']].append(row.to_dict())
     return grupos
 
-def formatar_moeda(valor):
-    """Formata valor como moeda brasileira."""
-    try:
-        return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
-    except:
-        return f"R$ {valor}"
+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
+    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."
 
-def buscar_combinacoes_eficiente(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de forma eficiente e garantida."""
-    try:
-        print("🔍 Iniciando busca de combinações...")
-        
-        if df is None:
-            print("⚠️ DataFrame não carregado, tentando carregar...")
-            if not carregar_planilha():
-                return "❌ Erro: Planilha não carregada."
-
-        # Debug: verifica se o DataFrame foi carregado
-        print(f"✅ DataFrame carregado com {len(df)} linhas")
-        print(f"📋 Colunas disponíveis: {list(df.columns)}")
-        
-        # Filtra por tipo de bem
-        if 'tipo_do_bem' not in df.columns:
-            return "❌ Coluna 'tipo_do_bem' não encontrada na planilha."
-            
-        df_filtrado = df[df['tipo_do_bem'].str.lower() == 'imovel']
-        print(f"📊 Imóveis filtrados: {len(df_filtrado)} linhas")
-        
-        if administradoras:
-            if isinstance(administradoras, tuple):
-                administradoras = list(administradoras)
-            print(f"🎯 Administradoras selecionadas: {administradoras}")
-            df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
-            print(f"📊 Após filtrar administradoras: {len(df_filtrado)} linhas")
-
-        if df_filtrado.empty:
-            return "🚫 Nenhuma cota encontrada com os filtros aplicados."
-
-        # Debug: mostra algumas administradoras disponíveis
-        adm_disponiveis = df_filtrado['administradora'].unique()[:5]
-        print(f"🏢 Primeiras administradoras disponíveis: {adm_disponiveis}")
-
-        # 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)
-        print(f"📦 Grupos formados: {len(grupos)} administradoras")
-        
-        resultados = []
-        MIN_COTAS = 3
-        MAX_COTAS = 10
-
-        for adm, cotas in grupos.items():
-            print(f"🔍 Processando {adm} com {len(cotas)} cotas")
-            
-            if len(cotas) < MIN_COTAS:
-                continue
-                
-            # Ordena por valor de crédito (otimização)
-            cotas_ordenadas = sorted(cotas, key=lambda x: x.get('valor_credito', 0))
-            
-            # Busca combinações de forma inteligente
-            for tamanho in range(MIN_COTAS, min(MAX_COTAS + 1, len(cotas_ordenadas) + 1)):
-                # Amostra para evitar explosão combinatória
-                for i in range(0, len(cotas_ordenadas), max(1, len(cotas_ordenadas) // 5)):
-                    for j in range(i + tamanho, min(i + 20, len(cotas_ordenadas))):
-                        combinacao = cotas_ordenadas[i:j]
-                        if len(combinacao) != tamanho:
-                            continue
-                            
-                        try:
-                            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.get('valor_parcela', 0) 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.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))
-                                
-                                if len(resultados) >= 50:
-                                    break
-                        except Exception as e:
-                            print(f"⚠️ Erro em combinação: {e}")
-                            continue
-                    
-                    if len(resultados) >= 50:
-                        break
-                        
-                if len(resultados) >= 50:
-                    break
-                    
-            if len(resultados) >= 50:
-                break
-
-        print(f"✅ Busca concluída: {len(resultados)} combinações encontradas")
-        
-        if not resultados:
-            return "🚫 Nenhuma combinação adequada encontrada. Tente ampliar os filtros."
-
-        resultados.sort(key=lambda x: x[2])
-        return formatar_resultados(resultados[:15])
-        
-    except Exception as e:
-        error_msg = f"❌ Erro inesperado: {str(e)}"
-        print(error_msg)
-        return error_msg
+    # 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)]
 
-def formatar_resultados(resultados):
-    """Formata os resultados para exibição com diversificação por administradora."""
-    from collections import defaultdict
-    
-    if not resultados or isinstance(resultados, str):
-        return resultados
-        
-    resposta = ""
-    
-    # 1. Agrupar os resultados por administradora, mantendo a diferença para ordenação interna
-    grouped_by_adm = defaultdict(list)
-    for adm, combinacao, diferenca in resultados:
-        grouped_by_adm[adm].append((combinacao, diferenca))
+    if df_filtrado.empty:
+        return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
 
-    # 2. Ordenar as combinações dentro de cada administradora pela diferença (do menor para o maior)
-    for adm in grouped_by_adm:
-        grouped_by_adm[adm].sort(key=lambda x: x[1]) # x[1] é a diferença
+    # 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
 
-    final_resultados_diversificados = []
-    
-    # Dicionário para acompanhar o índice da próxima combinação a ser pega de cada administradora
-    adm_indices = {adm: 0 for adm in grouped_by_adm.keys()}
+    grupos = agrupar_por_administradora(df_filtrado)
+    resultados = []
 
-    # Lista de administradoras ativas (que ainda têm combinações disponíveis)
-    active_adms = list(grouped_by_adm.keys())
-    
-    current_adm_idx = 0 # Índice para ciclar entre as administradoras ativas
-    
-    # Loop para selecionar até 15 combinações, garantindo diversidade
-    while len(final_resultados_diversificados) < 15 and active_adms:
-        # Pega a administradora da vez para selecionar uma combinação
-        adm_da_vez = active_adms[current_adm_idx]
-        
-        # Pega o índice da próxima combinação para essa administradora
-        idx_na_adm = adm_indices[adm_da_vez]
-        
-        # Verifica se essa administradora ainda tem combinações disponíveis
-        if idx_na_adm < len(grouped_by_adm[adm_da_vez]):
-            # Pega a combinação (ignorando a diferença, que já foi usada para ordenar internamente)
-            combinacao_data, _ = grouped_by_adm[adm_da_vez][idx_na_adm]
-            
-            # Adiciona à lista de resultados final (com a administradora e a combinação)
-            final_resultados_diversificados.append((adm_da_vez, combinacao_data))
-            
-            # Incrementa o índice para a próxima vez que pegarmos dessa administradora
-            adm_indices[adm_da_vez] += 1
-        else:
-            # Se essa administradora não tem mais combinações, remove ela da lista de ativas
-            active_adms.pop(current_adm_idx)
-            # Ajusta o current_adm_idx se a lista diminuiu e estamos no limite
-            if current_adm_idx >= len(active_adms) and active_adms:
-                 current_adm_idx = 0 # Volta para o início da lista se removemos o último
-
-        # Move para a próxima administradora no ciclo (garantindo que não estouramos o índice da lista active_adms)
-        if active_adms: # Só avança se ainda houver administradoras ativas
-            current_adm_idx = (current_adm_idx + 1) % len(active_adms)
-        else:
-            break # Não há mais administradoras ativas, sai do loop
-            
-    # Agora, itera sobre os resultados diversificados para formatar a resposta
-    for idx, (adm, combinacao) in enumerate(final_resultados_diversificados, 1):
+    for adm, cotas in grupos.items():
+        for r in range(1, min(3, len(cotas)) + 1):  # Máximo 3 cotas por combinação
+            for combinacao in itertools.combinations(cotas, 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)  # aplica os 8,5% sobre o crédito
+                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) # Diferença do valor final pelo crédito (para ordenação)
+
+                    resultados.append((adm, combinacao, diferenca))
+
+    if not resultados:
+        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+
+    resultados.sort(key=lambda x: x[2]) # Ordena pela diferença
+
+    return formatar_resultados(resultados)
+
+def formatar_moeda(valor):
+    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+
+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):
         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)
@@ -247,84 +135,125 @@ def formatar_resultados(resultados):
         taxa_percentual = (taxa_total / credito_real) * 100 if credito_real > 0 else 0
         taxa_mensal = taxa_percentual / maior_prazo if maior_prazo > 0 else 0
 
-        # FORMATAÇÃO COMPLETA IDÊNTICA AO CARD DE AUTOMÓVEL
         resposta += f"""
-## {adm} - Imóvel
-
-### Crédito
-**{formatar_moeda(total_credito)}**
-
-**Entrada:** {formatar_moeda(total_entrada)}  
-**Prazo:** {maior_prazo} meses  
-**Parcela:** {formatar_moeda(total_parcelas)}  
-
-**Saldo Devedor:** {formatar_moeda(total_saldo)}  
-**Taxa Mensal:** {taxa_mensal:.2f}%  
-**Taxa Anual:** {taxa_mensal * 12:.2f}%  
-**Código:** {', '.join(codigos)}  
-
----
-
-### Ver mais detalhes ▼
-
-**Valor Final:** {formatar_moeda(valor_final)}  
-**Crédito Líquido:** {formatar_moeda(credito_real)}  
-**Taxa Total:** {taxa_percentual:.2f}% ({formatar_moeda(taxa_total)})  
-
-**Nº de Cotas:** {len(combinacao)}
-
----
-
+--- COMBINAÇÃO {idx} ---
+🏢 Administradora: {adm}
+🔢 Códigos: {', '.join(codigos)}
+💰 Crédito Total: {formatar_moeda(total_credito)}
+💵 Entrada (+comissão): {formatar_moeda(total_entrada)}
+📉 Saldo Devedor: {formatar_moeda(total_saldo)}
+💲 Parcela: {formatar_moeda(total_parcelas)}
+⏳ 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 Mensal: {taxa_mensal:.2f}%
+🗓️ Taxa Anual: {taxa_mensal * 12:.2f}%
 """
     return resposta
 
-def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
-    """Função principal ajustada para a interface."""
-    try:
-        if credito_desejado is None or entrada_desejada is None or parcela_desejada is None:
-            return "⚠️ Preencha todos os valores corretamente."
-            
-        entrada_calculada = credito_desejado * 0.085 + entrada_desejada
-        
-        resultado = buscar_combinacoes_rapido(
-            credito_desejado, entrada_calculada, parcela_desejada, administradoras
-        )
-        
-        return resultado
-        
-    except Exception as e:
-        return f"❌ Erro na busca: {str(e)}"
-
-# Carrega a planilha ao iniciar
+# Carrega a planilha uma vez quando o aplicativo inicia
 carregar_planilha()
 
+def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
+    entrada_calculada = credito_desejado * 0.085 + entrada_desejada
+    return buscar_combinacoes(credito_desejado, entrada_calculada, parcela_desejada, administradoras)
+
 # Prepara a lista de administradoras para o Gradio
 def get_administradoras_options():
-    try:
-        if df is not None and 'administradora' in df.columns and 'tipo_do_bem' in df.columns:
-            adm_list = df[df['tipo_do_bem'].str.lower() == 'imovel']['administradora'].unique()
-            return sorted([adm for adm in adm_list if pd.notna(adm)])
-        return []
-    except:
-        return []
-
-# Interface Gradio simplificada
-with gr.Blocks(title="Sistema de Busca de Consórcio", theme=gr.themes.Default()) as demo:
-    gr.Markdown("# 🏠 Busca de Combinações de Consórcio Imóvel")
+    if df is not None:
+        adm_list = df[df['tipo_do_bem'].str.lower() == 'imovel']['administradora'].unique()
+        return sorted(adm_list)
+    return []
+
+# Criando a interface Gradio
+with gr.Blocks(title="Sistema de Busca de Consórcio Imóvel") as demo:
+    gr.HTML("""
+    <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
+    <style>
+        * {
+            font-family: 'Poppins', sans-serif !important;
+        }
+    
+        body {
+            background-color: #ff8f00 !important;
+            color: black !important;
+        }
     
+        /* Inputs Numéricos: Crédito, Entrada, Parcela */
+        input[type="number"] {
+            background-color: white !important;
+            border: 2px solid #000 !important;
+            border-radius: 12px !important;
+            color: black !important;
+            padding: 10px !important;
+            font-weight: 500;
+        }
+    
+        /* Inputs de texto e áreas de texto (como a saída e código) */
+        input[type="text"], textarea {
+            background-color: white !important;
+            border: 2px solid black !important;
+            border-radius: 12px !important;
+            color: black !important;
+            padding: 10px !important;
+        }
+    
+        input::placeholder, textarea::placeholder {
+            color: #333 !important;
+            opacity: 0.7;
+        }
+    
+        .gr-checkbox label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-weight: 600;
+        }
+    
+        input[type="checkbox"] {
+            accent-color: black !important;
+            width: 18px;
+            height: 18px;
+        }
+    
+        .gr-button {
+            font-weight: bold;
+            border-radius: 10px !important;
+            background-color: white !important;
+            color: black !important;
+            border: 2px solid black !important;
+        }
+    
+        .gr-button:hover {
+            background-color: #fff3e0 !important;
+            color: black !important;
+        }
+    
+        label {
+            font-weight: 600 !important;
+        }
+    </style>
+    """)
+
+
+    gr.Markdown("# 🏠 Busca de Combinações de Consórcio Imóvel")
+    gr.Markdown("Insira os valores desejados para crédito, entrada e parcela, e filtre por administradora.")
+
     with gr.Row():
-        credito_input = gr.Number(label="Crédito Desejado (R$)", value=2000000, step=1000)
-        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=300000, step=1000)
-        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=20000, step=100)
+        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)
 
     administradoras_multiselect = gr.CheckboxGroup(
         label="Filtrar por Administradoras",
         choices=get_administradoras_options(),
-        value=get_administradoras_options()
+        value=get_administradoras_options() # Seleciona todas por padrão
     )
 
     submit_btn = gr.Button("🔍 Buscar Combinações", variant="primary")
-    output_text = gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40)
+
+    output_text = gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40, interactive=False, placeholder="Os resultados aparecerão aqui...")
 
     submit_btn.click(
         fn=ajustar_e_buscar,
@@ -332,6 +261,9 @@ with gr.Blocks(title="Sistema de Busca de Consórcio", theme=gr.themes.Default()
         outputs=output_text
     )
 
-# Inicia o aplicativo
+    gr.Markdown("---")
+    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio ideais.")
+
+# Inicia o aplicativo Gradio
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    demo.launch() # Você não precisa disso no Colab, mas sim no arquivo que você fará o deploy