Update app.py

app.py

@@ -1,75 +1,110 @@
-import os
-os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
 import pandas as pd
 import requests
 import io
 import itertools
 from collections import defaultdict
 import gradio as gr
+import time
+import math
 
+# 🔧 CONFIGURAÇÕES GLOBAIS
 FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
 URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 
+# Variáveis globais para armazenamento
+df = None
 df_auto = None
 grupos_auto = None
 planilha_carregada = False
-ADMIN_OPCOES = []
 
 def carregar_planilha():
-    global df_auto, grupos_auto, planilha_carregada, ADMIN_OPCOES
+    """Carrega e prepara a planilha para análise."""
+    global df, df_auto, grupos_auto, planilha_carregada
+    
+    # Se já carregou, não precisa carregar novamente
     if planilha_carregada:
         return True
+        
     try:
         print("⏳ Carregando planilha...")
         response = requests.get(URL)
         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(" ", "_")
+
+        # Padroniza os nomes das administradoras
+        if 'administradora' in df.columns:
+            df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
+
+        # Converte colunas numéricas
         colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
-        for col in colunas_numericas:
-            if col in df.columns:
-                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
+        for coluna in colunas_numericas:
+            if coluna in df.columns:
+                df[coluna] = pd.to_numeric(df[coluna], errors='coerce').fillna(0)
+
+        # Verifica colunas essenciais
         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)
+        
+        # Pré-filtra e pré-processa dados de auto
         df_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
-        df_auto['administradora'] = df_auto['administradora'].astype(str).str.strip().str.lower()
-        df_auto = df_auto[df_auto['administradora'].notna() & (df_auto['administradora'] != '')]
-        grupos_auto = defaultdict(list)
-        for _, row in df_auto.iterrows():
-            grupos_auto[row['administradora']].append(row.to_dict())
-        ADMIN_OPCOES = sorted(df_auto['administradora'].unique())
+        grupos_auto = agrupar_por_administradora(df_auto)
+
         planilha_carregada = True
-        print(f"✅ Total de cotas: {len(df_auto)}")
-        print(f"✅ Administradoras: {ADMIN_OPCOES}")
+        print("✅ Planilha carregada e pré-processada com sucesso")
+        print(f"✅ Total de cotas de auto: {len(df_auto)}")
+        print(f"✅ Administradoras disponíveis: {list(grupos_auto.keys())}")
         return True
+
     except Exception as e:
-        print(f"❌ Erro: {e}")
+        print(f"❌ Erro ao carregar planilha: {str(e)}")
         return False
 
-def formatar_moeda(valor):
-    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+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 calcular_tempo_parcelas(combinacao):
+    """Calcula o tempo de parcelas baseado nas cotas da combinação - VERSÃO CORRIGIDA."""
     if not combinacao:
         return ""
+    
     try:
+        # Ordena as cotas pelo prazo (menor prazo primeiro)
         cotas_ordenadas = sorted(combinacao, key=lambda x: int(x.get('qtd_parcelas', 0)))
+        
+        # Encontra todos os prazos únicos e ordena
         prazos = sorted(set(int(c.get('qtd_parcelas', 0)) for c in combinacao))
+        
         if not prazos or prazos[0] <= 0:
             return ""
+        
         resultado = []
         prazo_anterior = 0
-        for prazo_atual in prazos:
+        
+        for i, prazo_atual in enumerate(prazos):
+            # Calcula a soma das parcelas das cotas que estão ativas neste intervalo
             cotas_ativas = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) >= prazo_anterior + 1]
             valor_parcela_total = sum(c.get('valor_parcela', 0) for c in cotas_ativas)
+            
             inicio = prazo_anterior + 1
             fim = prazo_atual
+            
             if inicio <= fim and valor_parcela_total > 0:
                 resultado.append(f"{inicio}x à {fim}x: {formatar_moeda(valor_parcela_total)}/mês")
+            
             prazo_anterior = prazo_atual
+        
+        # Adiciona faixa final se houver cotas com prazos além do último ponto de quebra
         if prazos and prazo_anterior < max(prazos):
             cotas_ativas_finais = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) > prazo_anterior]
             if cotas_ativas_finais:
@@ -78,124 +113,381 @@ def calcular_tempo_parcelas(combinacao):
                 fim_final = max(prazos)
                 if valor_parcela_final > 0:
                     resultado.append(f"{inicio_final}x à {fim_final}x: {formatar_moeda(valor_parcela_final)}/mês")
+        
         return "\n".join(resultado) if resultado else ""
+    
     except Exception as e:
-        print(f"Erro tempo: {e}")
+        print(f"❌ Erro ao calcular tempo de parcelas: {str(e)}")
         return ""
 
-def buscar_combinacoes(credito, entrada, parcela, adm_selecionadas):
+def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=15):
+    """Busca combinações de cotas dentro dos parâmetros especificados de forma otimizada."""
+    global df_auto, grupos_auto
+    
+    # Garante que o DataFrame está carregado
     if not planilha_carregada:
         if not carregar_planilha():
-            return "❌ Erro: planilha não carregada."
-    if adm_selecionadas:
-        grupos = {adm: cotas for adm, cotas in grupos_auto.items() if adm in adm_selecionadas}
+            return "❌ Erro: Planilha não carregada. Por favor, tente novamente."
+
+    # Filtra administradoras se especificado
+    if administradoras and len(administradoras) > 0:
+        administradoras = [a.strip().lower() for a in administradoras]
+        grupos_filtrados = {adm: cotas for adm, cotas in grupos_auto.items() if adm in administradoras}
+        print(f"🔍 Filtrando por administradoras: {administradoras}")
     else:
-        grupos = grupos_auto
-    if not grupos:
-        return "🚫 Nenhuma cota encontrada com os filtros."
-
-    if credito > 5000000:
-        tol_cred, tol_ent, tol_par = 0.50, 0.50, 1.00
-        max_cotas = 25
-    elif credito > 100000:
-        tol_cred, tol_ent, tol_par = 0.25, 0.25, 0.50
-        max_cotas = 15
+        grupos_filtrados = grupos_auto
+        print("🔍 Buscando em todas as administradoras")
+
+    if not grupos_filtrados:
+        return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
+
+    print(f"🔍 Total de administradoras no filtro: {len(grupos_filtrados)}")
+    
+    # TOLERÂNCIAS - Ajustadas para valores de auto (geralmente menores que imóveis)
+    if credito_desejado > 5000000:  # Para valores acima de 5 Milhões
+        tolerancia_credito = 0.50  # 10%
+        tolerancia_entrada = 0.50  # 10%
+        tolerancia_parcela = 1.00  # 50%
+        max_cotas_combinacao = 25   # Até 25 cotas por combinação
+    elif credito_desejado > 100000:  # Para valores acima de 100 Mil
+        tolerancia_credito = 0.25  # 10%
+        tolerancia_entrada = 0.25  # 10%
+        tolerancia_parcela = 0.50  # 30%
+        max_cotas_combinacao = 15   # Até 15 cotas por combinação
+    else:  # Para valores até 100k
+        tolerancia_credito = 0.15  # 5%
+        tolerancia_entrada = 0.15  # 5%
+        tolerancia_parcela = 0.30  # 25%
+        max_cotas_combinacao = 15   # Até 15 cotas por combinação
+
+    # Define faixas de tolerância
+    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"💰 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():
+        print(f"🔍 Analisando administradora: {adm} ({len(cotas)} cotas)")
+        
+        # Para valores altos, NÃO filtramos cotas individuais primeiro
+        cotas_para_combinar = cotas
+        
+        # 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
+            if credito_desejado > 500000:
+                max_combinacoes_por_adm = 5000
+            else:
+                max_combinacoes_por_adm = 2000
+            combinacoes_geradas = 0
+            
+            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):
+
+                    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))
+                    
+                    # Para se já encontrou combinações suficientes
+                    if len(resultados) >= max_combinacoes * 3:
+                        break
+            
+            if len(resultados) >= max_combinacoes * 3:
+                break
+        
+        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:
+        # 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=15):
+    """Busca combinações com tolerâncias mais amplas para valores altos."""
+    global grupos_auto
+    
+    # Filtra administradoras se especificado
+    if administradoras and len(administradoras) > 0:
+        administradoras = [a.strip().lower() for a in administradoras]
+        grupos_filtrados = {adm: cotas for adm, cotas in grupos_auto.items() if adm in administradoras}
+    else:
+        grupos_filtrados = grupos_auto
+
+    # Tolerâncias mais amplas para valores altos
+    if credito_desejado > 5000000:
+        tolerancia_credito = 0.50  # 15%
+        tolerancia_entrada = 0.50  # 15%
+        tolerancia_parcela = 1.00  # 75%
+        max_cotas_combinacao = 25  # Até 10 cotas por combinação
+    elif credito_desejado > 100000:
+        tolerancia_credito = 0.25  # 10%
+        tolerancia_entrada = 0.25  # 10%
+        tolerancia_parcela = 0.50  # 50%
+        max_cotas_combinacao = 15   # Até 8 cotas por combinação
     else:
-        tol_cred, tol_ent, tol_par = 0.15, 0.15, 0.30
-        max_cotas = 15
+        tolerancia_credito = 0.15  # 5%
+        tolerancia_entrada = 0.15  # 5%
+        tolerancia_parcela = 0.30  # 35%
+        max_cotas_combinacao = 15   # Até 6 cotas por combinação
 
-    cred_min = credito * (1 - tol_cred)
-    cred_max = credito * (1 + tol_cred)
-    ent_min = entrada * (1 - tol_ent)
-    ent_max = entrada * (1 + tol_ent)
-    parc_min = parcela * (1 - tol_par)
-    parc_max = parcela * (1 + tol_par)
+    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 = []
-    for adm, cotas in grupos.items():
-        for r in range(1, min(max_cotas + 1, len(cotas) + 1)):
-            for comb in itertools.combinations(cotas, r):
-                total_cred = sum(c['valor_credito'] for c in comb)
-                total_ent_base = sum(c['valor_entrada'] for c in comb)
-                total_ent = total_ent_base + total_cred * 0.085
-                total_parc = sum(c['valor_parcela'] for c in comb)
-                if (cred_min <= total_cred <= cred_max and
-                    ent_min <= total_ent <= ent_max and
-                    parc_min <= total_parc <= parc_max):
-                    total_saldo = sum(c['saldo_devedor'] for c in comb)
-                    valor_final = total_ent + total_saldo
-                    diff = abs(valor_final - total_cred)
-                    resultados.append((adm, comb, diff))
-                    if len(resultados) >= 30:
+    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 = 5000
+            
+            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) >= 30:
+            
+            if len(resultados) >= max_combinacoes * 2:
                 break
-        if len(resultados) >= 30:
+        
+        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 encontrada."
+        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+
     resultados.sort(key=lambda x: x[2])
-    return formatar_resultados(resultados[:15])
+    return formatar_resultados(resultados[:max_combinacoes])
+
+def formatar_moeda(valor):
+    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
 
 def formatar_resultados(resultados):
+    """Formata os resultados para exibição INCLUINDO TEMPO DE PARCELAS CORRETO."""
     if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada."
+        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+    
     resposta = ""
-    for idx, (adm, comb, _) in enumerate(resultados, 1):
-        codigos = [str(c.get('codigo', 'N/A')) for c in comb]
-        total_cred = sum(c['valor_credito'] for c in comb)
-        total_ent_base = sum(c['valor_entrada'] for c in comb)
-        total_ent = total_ent_base + total_cred * 0.085
-        total_saldo = sum(c['saldo_devedor'] for c in comb)
-        total_parc = sum(c['valor_parcela'] for c in comb)
-        maior_prazo = max(int(c.get('qtd_parcelas', 0)) for c in comb)
-        valor_final = total_ent + total_saldo
-        cred_real = total_cred - total_ent
-        taxa_total = total_saldo - cred_real
-        taxa_perc = (taxa_total / cred_real) * 100 if cred_real > 0 else 0
-        taxa_mensal = taxa_perc / maior_prazo if maior_prazo > 0 else 0
-        tempo = calcular_tempo_parcelas(comb)
+    for idx, (adm, combinacao, _) in enumerate(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.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
+        
+        # CHAMADA CORRIGIDA para calcular tempo de parcelas
+        tempo_parcelas = calcular_tempo_parcelas(combinacao)
+
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
 🏢 Administradora: {adm}
-🔢 Códigos: {', '.join(codigos)} ({len(comb)} cotas)
-💰 Crédito Total: {formatar_moeda(total_cred)}
-💵 Entrada (+comissão): {formatar_moeda(total_ent)}
+🔢 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)}
-💲 Parcela: {formatar_moeda(total_parc)}
+💲 Parcela: {formatar_moeda(total_parcelas)}
 ⏳ Prazo: {maior_prazo} meses
 🔚 Valor Final: {formatar_moeda(valor_final)}
-💠 Crédito Líquido: {formatar_moeda(cred_real)}
-📊 Taxa Total: {taxa_perc:.2f}% ({formatar_moeda(taxa_total)})
+💠 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}%
 ⏰ TEMPO DE PARCELAS:
-{tempo if tempo else "Não foi possível calcular"}
+{tempo_parcelas if tempo_parcelas else "Não foi possível calcular o tempo de parcelas"}
 """
     return resposta
 
-# Carrega a planilha antes de iniciar
+# Carrega a planilha uma vez quando o aplicativo inicia
 carregar_planilha()
 
-# Interface usando gr.Interface (API automática em /api/predict)
-demo = gr.Interface(
-    fn=buscar_combinacoes,
-    inputs=[
-        gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000),
-        gr.Number(label="Entrada Desejada (R$)", value=3000, step=100),
-        gr.Number(label="Parcela Desejada (R$)", value=500, step=10),
-        gr.Dropdown(
-            choices=ADMIN_OPCOES,
-            label="Filtrar por Administradoras",
-            multiselect=True,
-            value=ADMIN_OPCOES
-        )
-    ],
-    outputs=gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40),
-    title="🚗 Busca de Combinações de Consórcio Auto",
-    description="Insira os valores desejados para crédito, entrada e parcela, e filtre por administradora."
-)
+def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
+    return buscar_combinacoes_otimizado(
+        credito_desejado, entrada_desejada, parcela_desejada, administradoras, max_combinacoes=15
+    )
+
+# Prepara a lista de administradoras para o Gradio
+def get_administradoras_options():
+    if df is not None and planilha_carregada:
+        adm_list = df[df['tipo_do_bem'].str.lower() == 'auto']['administradora'].unique()
+        return sorted(adm_list)
+    return []
+
+# Criando a interface Gradio
+with gr.Blocks(title="Sistema de Busca de Consórcio Auto") 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 Auto")
+    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=30000, step=1000)
+        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100)
+        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10)
+
+    administradoras_multiselect = gr.CheckboxGroup(
+        label="Filtrar por Administradoras",
+        choices=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, interactive=False, placeholder="Os resultados aparecerão aqui...")
+
+    submit_btn.click(
+        fn=ajustar_e_buscar,
+        inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect],
+        outputs=output_text
+    )
+
+    gr.Markdown("---")
+    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio ideais.")
 
+# Inicia o aplicativo Gradio
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()
+#