import pandas as pd import requests import io import itertools from collections import defaultdict import gradio as gr import time import random # 🔧 CONFIGURAÇÕES GLOBAIS 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.""" global df try: print("⏳ Carregando planilha...") response = requests.get(URL, timeout=30) response.raise_for_status() data = io.BytesIO(response.content) df = pd.read_excel(data) # Padroniza nomes das colunas df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_") # Converte colunas numéricas 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 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}") # Remove duplicatas df.drop_duplicates(inplace=True) print("✅ Planilha 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 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_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 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)) # 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 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()} # 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): 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.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) 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 # 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)} --- """ 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 carregar_planilha() # 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") 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) administradoras_multiselect = gr.CheckboxGroup( label="Filtrar por Administradoras", choices=get_administradoras_options(), value=get_administradoras_options() ) submit_btn = gr.Button("🔍 Buscar Combinações", variant="primary") output_text = gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40) submit_btn.click( fn=ajustar_e_buscar, inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect], outputs=output_text ) # Inicia o aplicativo if __name__ == "__main__": demo.launch(server_name="0.0.0.0", server_port=7860, share=False)