Update app.py

app.py

@@ -1,24 +1,34 @@
-# -- coding: utf-8 --
-"""Robô de Cálculo para Consórcio de Imóveis - Versão Ajustada"""
+# -*- coding: utf-8 -*-
+"""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
 import itertools
 from collections import defaultdict
 import gradio as gr
+import time
 
 # 🔧 CONFIGURAÇÕES GLOBAIS
-FILE_ID = "1XvNz7DlWioT64uNdcfBSL8Ui2nRSi9gT"  # Substitua pelo ID correto da planilha de imóveis
+# 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}"
 
 # Variável global para armazenar o DataFrame
 df = None
 
 def carregar_planilha():
-    """Carrega e prepara a planilha para análise de consórcios de imóveis."""
+    """Carrega e prepara a planilha para análise."""
     global df
     try:
-        print("⏳ Carregando planilha de imóveis...")
+        print("⏳ Carregando planilha...")
         response = requests.get(URL)
         response.raise_for_status()
         data = io.BytesIO(response.content)
@@ -26,30 +36,23 @@ def carregar_planilha():
 
         # Padroniza nomes das colunas
         df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
+        df['administradora'] = df['administradora'].str.strip().str.lower()
 
-        # Padroniza os nomes das administradoras
-        if 'administradora' in df.columns:
-            df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
 
         # Converte colunas numéricas
-        numeric_cols = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
-        for col in numeric_cols:
-            if col in df.columns:
-                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
-
-        # Filtra apenas imóveis (com tratamento para diferentes grafias)
-        if 'tipo_do_bem' in df.columns:
-            df = df[df['tipo_do_bem'].str.lower().str.contains('imóvel|imovel')]
-        
+        colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
+        for coluna in colunas_numericas:
+            if coluna in df.columns:
+                df[coluna] = pd.to_numeric(df[coluna], errors='coerce').fillna(0)
+
         # Verifica colunas essenciais
-        required_cols = ['tipo_do_bem', 'administradora', 'valor_credito', 'valor_entrada', 'valor_parcela']
-        if not all(col in df.columns for col in required_cols):
-            missing = [col for col in required_cols if col not in df.columns]
-            raise ValueError(f"Colunas essenciais não encontradas: {', '.join(missing)}")
+        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)
-        print("✅ Planilha de imóveis carregada com sucesso!")
+
+        print("✅ Planilha carregada com sucesso")
         return True
 
     except Exception as e:
@@ -64,28 +67,29 @@ def agrupar_por_administradora(dataframe):
     return grupos
 
 def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de cotas para imóveis dentro dos parâmetros especificados."""
-    global df
+    """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. Verifique o ID do arquivo e conexão."
+            return "❌ Erro: Planilha não carregada. Por favor, tente novamente."
 
-    # Filtra por tipo de bem (Imóvel) e administradoras selecionadas
-    df_filtrado = df[df['tipo_do_bem'].str.lower().str.contains('imóvel|imovel')]
-    
+    # 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)
         administradoras = [a.strip().lower() for a in administradoras]
         df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
 
     if df_filtrado.empty:
-        return "🚫 Nenhuma cota de imóvel encontrada com os filtros aplicados."
+        return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
 
-    # Define faixas de tolerância ajustadas para imóveis
-    credito_min, credito_max = credito_desejado * 0.90, credito_desejado * 1.10
-    entrada_min, entrada_max = entrada_desejada * 0.90, entrada_desejada * 1.10
-    parcela_min, parcela_max = parcela_desejada * 0.70, parcela_desejada * 1.30
+    # 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
 
     grupos = agrupar_por_administradora(df_filtrado)
     resultados = []
@@ -95,7 +99,7 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
             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.10)  # 10% de comissão para imóveis
+                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
@@ -104,63 +108,29 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
 
                     total_saldo = sum(c['saldo_devedor'] for c in combinacao)
                     valor_final = round(total_entrada + total_saldo, 2)
-                    diferenca = abs(valor_final - total_credito)
+                    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 para imóveis com os parâmetros fornecidos."
+        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+
+    resultados.sort(key=lambda x: x[2]) # Ordena pela diferença
 
-    resultados.sort(key=lambda x: x[2])  # Ordena pela diferença
     return formatar_resultados(resultados)
 
 def formatar_moeda(valor):
-    """Formata valores monetários no padrão brasileiro."""
     return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
 
 def formatar_resultados(resultados):
-    """Formata os resultados para exibição com diversificação."""
+    """Formata os resultados para exibição."""
     resposta = ""
-    grouped_by_adm = defaultdict(list)
-    
-    # Agrupa por administradora mantendo a ordenação por diferença
-    for adm, combinacao, diferenca in resultados:
-        grouped_by_adm[adm].append((combinacao, diferenca))
-    
-    # Ordena as combinações dentro de cada administradora
-    for adm in grouped_by_adm:
-        grouped_by_adm[adm].sort(key=lambda x: x[1])
-
-    # Algoritmo de diversificação de resultados
-    final_resultados = []
-    adm_indices = {adm: 0 for adm in grouped_by_adm.keys()}
-    active_adms = list(grouped_by_adm.keys())
-    current_adm_idx = 0
-
-    while len(final_resultados) < 15 and active_adms:
-        adm_da_vez = active_adms[current_adm_idx]
-        idx_na_adm = adm_indices[adm_da_vez]
-        
-        if idx_na_adm < len(grouped_by_adm[adm_da_vez]):
-            combinacao_data, _ = grouped_by_adm[adm_da_vez][idx_na_adm]
-            final_resultados.append((adm_da_vez, combinacao_data))
-            adm_indices[adm_da_vez] += 1
-        else:
-            active_adms.pop(current_adm_idx)
-            if current_adm_idx >= len(active_adms) and active_adms:
-                current_adm_idx = 0
-
-        if active_adms:
-            current_adm_idx = (current_adm_idx + 1) % len(active_adms)
-        else:
-            break
-
-    # Formatação dos resultados
-    for idx, (adm, combinacao) in enumerate(final_resultados, 1):
+    # 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)
-        total_entrada = total_entrada_base + (total_credito * 0.10)  # 10% para imóveis
+        total_entrada = total_entrada_base + (total_credito * 0.085)
         total_saldo = sum(c['saldo_devedor'] for c in combinacao)
         total_parcelas = sum(c['valor_parcela'] for c in combinacao)
         maior_prazo = max(int(c.get('qtd_parcelas', 0)) for c in combinacao)
@@ -173,39 +143,86 @@ def formatar_resultados(resultados):
 
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
-🏠 Administradora: {adm.capitalize()}
+🏢 Administradora: {adm}
 🔢 Códigos: {', '.join(codigos)}
 💰 Crédito Total: {formatar_moeda(total_credito)}
-🏦 Entrada (+comissão): {formatar_moeda(total_entrada)}
+💵 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}%
+🗓️ Taxa Mensal: {taxa_mensal:.2f}%
+🗓️ Taxa Anual: {taxa_mensal * 12:.2f}%
 """
     return resposta
 
+# 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():
-    """Obtém a lista de administradoras disponíveis para o filtro."""
     if df is not None:
-        adm_list = df[df['tipo_do_bem'].str.lower().str.contains('imóvel|imovel')]['administradora'].unique()
-        return sorted(adm_list.tolist())
+        adm_list = df[df['tipo_do_bem'].str.lower() == 'imovel']['administradora'].unique()
+        return sorted(adm_list)
     return []
 
-# Interface Gradio para Imóveis
-with gr.Blocks(title="Sistema de Busca de Consórcio de Imóveis", css="* {font-family: 'Poppins', sans-serif !important;}") as demo:
-    gr.Markdown("""
+# 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>
-        body { background-color: #ff8f00 !important; color: black !important; }
-        input[type="number"], textarea {
+        * {
+            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;
@@ -213,42 +230,46 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Imóveis", css="* {font-
             color: black !important;
             border: 2px solid black !important;
         }
-        .gr-button:hover { background-color: #fff3e0 !important; }
+    
+        .gr-button:hover {
+            background-color: #fff3e0 !important;
+            color: black !important;
+        }
+    
+        label {
+            font-weight: 600 !important;
+        }
     </style>
     """)
-    
-    gr.Markdown("# 🏠 Sistema de Busca de Consórcio de Imóveis")
-    gr.Markdown("Encontre as melhores combinações de cotas para seu consórcio imobiliário.")
+
+
+    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=300000, step=10000, minimum=50000)
-        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=30000, step=1000, minimum=5000)
-        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=1500, step=100, minimum=500)
+        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(),
-        interactive=True
+        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, interactive=False)
+
+    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=buscar_combinacoes,
+        fn=ajustar_e_buscar,
         inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect],
         outputs=output_text
     )
 
     gr.Markdown("---")
-    gr.Markdown("*Atenção:* Valores calculados incluem comissão de 10% sobre o crédito.")
-
-# Carrega a planilha ao iniciar
-if carregar_planilha():
-    print("✅ Sistema pronto para uso!")
-else:
-    print("⚠ Sistema carregado com limitações - planilha não disponível")
+    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio ideais.")
 
-if _name_ == "_main_":
-    demo.launch()
+# Inicia o aplicativo Gradio
+if __name__ == "__main__":
+    demo.launch() # Você não precisa disso no Colab, mas sim no arquivo que você fará o deploy