Update app.py

app.py

@@ -32,4 +32,223 @@ def carregar_planilha():
             df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
 
         # Converte colunas numéricas
-        numeric_cols = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_deve
+        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')]
+        
+        # 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)}")
+
+        # Remove duplicatas
+        df.drop_duplicates(inplace=True)
+        print("✅ Planilha de imóveis carregada com sucesso!")
+        return True
+
+    except Exception as e:
+        print(f"❌ Erro ao carregar planilha: {str(e)}")
+        return False
+
+def agrupar_por_administradora(dataframe):
+    """Agrupa cotas por administradora."""
+    grupos = defaultdict(list)
+    for _, row in dataframe.iterrows():
+        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 para imóveis dentro dos parâmetros especificados."""
+    global df
+    if df is None:
+        if not carregar_planilha():
+            return "❌ Erro: Planilha não carregada. Verifique o ID do arquivo e conexão."
+
+    # Filtra por tipo de bem (Imóvel) e administradoras selecionadas
+    df_filtrado = df[df['tipo_do_bem'].str.lower().str.contains('imóvel|imovel')]
+    
+    if administradoras:
+        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."
+
+    # 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
+
+    grupos = agrupar_por_administradora(df_filtrado)
+    resultados = []
+
+    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.10)  # 10% de comissão para imóveis
+                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 not resultados:
+        return "🚫 Nenhuma combinação adequada encontrada para imóveis com os parâmetros fornecidos."
+
+    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."""
+    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):
+        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_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)
+
+        valor_final = round(total_entrada + total_saldo, 2)
+        credito_real = round(total_credito - total_entrada, 2)
+        taxa_total = total_saldo - credito_real
+        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
+
+        resposta += f"""
+--- COMBINAÇÃO {idx} ---
+🏠 Administradora: {adm.capitalize()}
+🔢 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 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())
+    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("""
+    <style>
+        body { background-color: #ff8f00 !important; color: black !important; }
+        input[type="number"], textarea {
+            background-color: white !important;
+            border: 2px solid #000 !important;
+            border-radius: 12px !important;
+            padding: 10px !important;
+        }
+        .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; }
+    </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.")
+
+    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)
+
+    administradoras_multiselect = gr.CheckboxGroup(
+        label="Filtrar por Administradoras",
+        choices=get_administradoras_options(),
+        value=get_administradoras_options(),
+        interactive=True
+    )
+
+    submit_btn = gr.Button("🔍 Buscar Combinações", variant="primary")
+    output_text = gr.Textbox(label="Resultados da Busca", lines=20, interactive=False)
+
+    submit_btn.click(
+        fn=buscar_combinacoes,
+        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")
+
+if _name_ == "_main_":
+    demo.launch()