Update app.py

app.py

@@ -1,8 +1,18 @@
+# 🔥 LIMITES DE SEGURANÇA - PARA EVITAR TIMEOUT NO HUGGING FACE
+import os
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
+os.environ["GRADIO_QUEUE_ENABLED"] = "False"
+
+MAX_COMBINATIONS = 10000  # Limite absoluto de combinações testadas
+MAX_COTAS_POR_ADMIN = 100  # Limita cotas por administradora
+
+# IMPORTS
 import pandas as pd
 import requests
 import io
 import itertools
 from collections import defaultdict
+import gradio as gr
 import time
 import math
 
@@ -26,17 +36,34 @@ def carregar_planilha():
         
     try:
         print("⏳ Carregando planilha...")
-        response = requests.get(URL, timeout=30)
-        response.raise_for_status()
-        data = io.BytesIO(response.content)
-        df = pd.read_excel(data)
-
+        
+        # PRIMEIRO: Tenta carregar do arquivo local (Hugging Face)
+        try:
+            # Verifica se o arquivo existe localmente
+            if os.path.exists("cotas_consorcio.xlsx"):
+                print("📁 Encontrado arquivo local no Hugging Face")
+                df = pd.read_excel("cotas_consorcio.xlsx")
+                print(f"✅ Planilha carregada do arquivo local: {len(df)} registros")
+            else:
+                raise FileNotFoundError("Arquivo local não encontrado")
+                
+        except Exception as e_local:
+            print(f"📁 Não foi possível carregar do arquivo local: {e_local}")
+            print("🌐 Tentando carregar do Google Drive...")
+            
+            # SEGUNDO: Tenta carregar do Google Drive
+            response = requests.get(URL, timeout=30)
+            response.raise_for_status()
+            data = io.BytesIO(response.content)
+            df = pd.read_excel(data)
+            print(f"✅ Planilha carregada do Google Drive: {len(df)} registros")
+
+        # =========== PROCESSAMENTO DA PLANILHA ===========
+        print("🔧 Processando planilha...")
+        
         # 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()
+        print("✅ Colunas padronizadas")
 
         # Converte colunas numéricas
         colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
@@ -45,15 +72,37 @@ def carregar_planilha():
                 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")
+        colunas_essenciais = ['tipo_do_bem', 'administradora']
+        for col in colunas_essenciais:
+            if col not in df.columns:
+                print(f"⚠️ Coluna essencial '{col}' não encontrada")
 
         # Remove duplicatas
         df.drop_duplicates(inplace=True)
+        print(f"✅ Duplicatas removidas: {len(df)} registros únicos")
         
         # Pré-filtra e pré-processa dados de auto
-        df_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
+        if 'tipo_do_bem' in df.columns:
+            # Busca por variações do termo 'auto'
+            termos_auto = ['auto', 'automóvel', 'carro', 'veículo', 'automovel']
+            mascara_auto = df['tipo_do_bem'].astype(str).str.lower().isin([t.lower() for t in termos_auto])
+            
+            if mascara_auto.any():
+                df_auto = df[mascara_auto].copy()
+                print(f"✅ Encontradas {len(df_auto)} cotas do tipo 'auto'")
+            else:
+                print("⚠️ Nenhuma cota do tipo 'auto' encontrada. Usando todos os registros.")
+                df_auto = df.copy()
+        else:
+            print("⚠️ Coluna 'tipo_do_bem' não encontrada. Usando todos os registros.")
+            df_auto = df.copy()
+        
+        # Agrupa por administradora
         grupos_auto = agrupar_por_administradora(df_auto)
+        
+        # 🔥 LIMITA COTAS POR ADMINISTRADORA PARA EVITAR TIMEOUT
+        for adm in list(grupos_auto.keys()):
+            grupos_auto[adm] = grupos_auto[adm][:MAX_COTAS_POR_ADMIN]
 
         planilha_carregada = True
         print("✅ Planilha carregada e pré-processada com sucesso")
@@ -63,13 +112,16 @@ def carregar_planilha():
 
     except Exception as e:
         print(f"❌ Erro ao carregar planilha: {str(e)}")
+        import traceback
+        traceback.print_exc()
         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())
+        if 'administradora' in row and row['administradora']:
+            grupos[row['administradora']].append(row.to_dict())
     return grupos
 
 def calcular_tempo_parcelas(combinacao):
@@ -119,19 +171,31 @@ def calcular_tempo_parcelas(combinacao):
         print(f"❌ Erro ao calcular tempo de parcelas: {str(e)}")
         return ""
 
-def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=15):
+def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=10):
     """Busca combinações de cotas dentro dos parâmetros especificados de forma otimizada."""
     global df_auto, grupos_auto
     
+    print(f"\n{'='*50}")
+    print(f"🔍 NOVA BUSCA - {time.strftime('%H:%M:%S')}")
+    print(f"💰 Crédito: R$ {credito_desejado:,.2f}")
+    print(f"💵 Entrada: R$ {entrada_desejada:,.2f}")
+    print(f"💲 Parcela: R$ {parcela_desejada:,.2f}")
+    print(f"🏢 Administradoras: {administradoras}")
+    
+    # 🔥 LIMITE DE SEGURANÇA - EVITA TIMEOUT
+    if credito_desejado > 1000000:  # 1 milhão
+        return "⚠️ Valor muito alto. Use valores até R$ 1.000.000 para evitar timeout."
+    
     # Garante que o DataFrame está carregado
     if not planilha_carregada:
+        print("📥 Planilha não carregada. Tentando carregar...")
         if not carregar_planilha():
             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}
+        grupos_filtrados = {adm: cotas for adm, cotas in grupos_auto.items() if adm.lower() in administradoras}
         print(f"🔍 Filtrando por administradoras: {administradoras}")
     else:
         grupos_filtrados = grupos_auto
@@ -147,17 +211,17 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
         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
+        max_cotas_combinacao = 10   # Até 10 cotas por combinação (REDUZIDO)
     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
+        max_cotas_combinacao = 8   # Até 8 cotas por combinação (REDUZIDO)
     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
+        max_cotas_combinacao = 6   # Até 6 cotas por combinação (REDUZIDO)
 
     # Define faixas de tolerância
     credito_min = credito_desejado * (1 - tolerancia_credito)
@@ -167,11 +231,7 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
     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 = []
@@ -188,9 +248,10 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
         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
+                max_combinacoes_por_adm = 1000  # REDUZIDO
             else:
-                max_combinacoes_por_adm = 2000
+                max_combinacoes_por_adm = 500   # REDUZIDO
+                
             combinacoes_geradas = 0
             
             for combinacao in itertools.combinations(cotas_para_combinar, r):
@@ -200,17 +261,22 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
                 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)
+                # 🔥 LIMITE GLOBAL DE COMBINAÇÕES TESTADAS
+                if total_combinacoes_testadas > MAX_COMBINATIONS:
+                    print(f"⚠️ Limite máximo de combinações atingido: {MAX_COMBINATIONS}")
+                    break
+                
+                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['valor_parcela'] for c in combinacao)
+                total_parcelas = sum(c.get('valor_parcela', 0) 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)
+                    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)
 
@@ -220,9 +286,15 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
                     if len(resultados) >= max_combinacoes * 3:
                         break
             
+            if total_combinacoes_testadas > MAX_COMBINATIONS:
+                break
+                
             if len(resultados) >= max_combinacoes * 3:
                 break
         
+        if total_combinacoes_testadas > MAX_COMBINATIONS:
+            break
+            
         if len(resultados) >= max_combinacoes * 3:
             break
 
@@ -238,14 +310,20 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
     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):
+def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=5):
     """Busca combinações com tolerâncias mais amplas para valores altos."""
     global grupos_auto
     
+    print(f"🔍 BUSCA AMPLA - {time.strftime('%H:%M:%S')}")
+    
+    # 🔥 LIMITE DE SEGURANÇA - EVITA TIMEOUT
+    if credito_desejado > 1000000:
+        return "⚠️ Busca ampla desativada para valores acima de R$ 1.000.000"
+    
     # 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}
+        grupos_filtrados = {adm: cotas for adm, cotas in grupos_auto.items() if adm.lower() in administradoras}
     else:
         grupos_filtrados = grupos_auto
 
@@ -254,17 +332,17 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
         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
+        max_cotas_combinacao = 8   # REDUZIDO
     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
+        max_cotas_combinacao = 6   # REDUZIDO
     else:
         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
+        max_cotas_combinacao = 4   # REDUZIDO
 
     credito_min = credito_desejado * (1 - tolerancia_credito)
     credito_max = credito_desejado * (1 + tolerancia_credito)
@@ -285,7 +363,7 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
         # Gera combinações
         for r in range(1, min(max_cotas_combinacao + 1, len(cotas) + 1)):
             combinacoes_geradas = 0
-            max_combinacoes_por_adm = 5000
+            max_combinacoes_por_adm = 300  # REDUZIDO
             
             for combinacao in itertools.combinations(cotas, r):
                 if combinacoes_geradas >= max_combinacoes_por_adm:
@@ -294,16 +372,21 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
                 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)
+                # 🔥 LIMITE GLOBAL DE COMBINAÇÕES TESTADAS
+                if total_combinacoes_testadas > MAX_COMBINATIONS:
+                    print(f"⚠️ Limite máximo de combinações atingido: {MAX_COMBINATIONS}")
+                    break
+                
+                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['valor_parcela'] for c in combinacao)
+                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['saldo_devedor'] for c in combinacao)
+                    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)
 
@@ -312,9 +395,15 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
                     if len(resultados) >= max_combinacoes * 2:
                         break
             
+            if total_combinacoes_testadas > MAX_COMBINATIONS:
+                break
+                
             if len(resultados) >= max_combinacoes * 2:
                 break
         
+        if total_combinacoes_testadas > MAX_COMBINATIONS:
+            break
+            
         if len(resultados) >= max_combinacoes * 2:
             break
 
@@ -328,7 +417,10 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
     return formatar_resultados(resultados[:max_combinacoes])
 
 def formatar_moeda(valor):
-    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+    try:
+        return f"R$ {float(valor):,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+    except:
+        return f"R$ {valor}"
 
 def formatar_resultados(resultados):
     """Formata os resultados para exibição INCLUINDO TEMPO DE PARCELAS CORRETO."""
@@ -337,13 +429,16 @@ def formatar_resultados(resultados):
     
     resposta = ""
     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)
+        codigos = [str(c.get('codigo', 'N/A')) for c in combinacao if c.get('codigo')]
+        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_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)
+        total_saldo = sum(c.get('saldo_devedor', 0) for c in combinacao)
+        total_parcelas = sum(c.get('valor_parcela', 0) for c in combinacao)
+        
+        # Encontra o maior prazo
+        prazos = [int(c.get('qtd_parcelas', 0)) for c in combinacao if c.get('qtd_parcelas')]
+        maior_prazo = max(prazos) if prazos else 0
 
         valor_final = round(total_entrada + total_saldo, 2)
         credito_real = round(total_credito - total_entrada, 2)
@@ -357,7 +452,7 @@ def formatar_resultados(resultados):
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
 🏢 Administradora: {adm}
-🔢 Códigos: {', '.join(codigos)} ({len(combinacao)} cotas)
+🔢 Códigos: {', '.join(codigos) if codigos else 'N/A'} ({len(combinacao)} cotas)
 💰 Crédito Total: {formatar_moeda(total_credito)}
 💵 Entrada (+comissão): {formatar_moeda(total_entrada)}
 📉 Saldo Devedor: {formatar_moeda(total_saldo)}
@@ -374,180 +469,191 @@ def formatar_resultados(resultados):
     return resposta
 
 # Carrega a planilha uma vez quando o aplicativo inicia
+print("🚀 Iniciando sistema de busca de consórcio...")
 carregar_planilha()
 
 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
-    )
+    print(f"\n📥 API CHAMADA - ajustar_e_buscar")
+    print(f"   Parâmetros: {credito_desejado}, {entrada_desejada}, {parcela_desejada}, {administradoras}")
+    
+    try:
+        resultado = buscar_combinacoes_otimizado(
+            float(credito_desejado), 
+            float(entrada_desejada), 
+            float(parcela_desejada), 
+            administradoras, 
+            max_combinacoes=10
+        )
+        print(f"✅ Resultado gerado com sucesso")
+        return resultado
+    except Exception as e:
+        print(f"❌ Erro em ajustar_e_buscar: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return f"❌ Erro interno do servidor: {str(e)}"
 
 # Prepara a lista de administradoras para o Gradio
 def get_administradoras_options():
+    """RETORNA AS ADMINISTRADORAS EM FORMATO ORIGINAL (COM LETRAS MAIÚSCULAS)"""
     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 []
-
-# Solução alternativa para importar Gradio
-try:
-    import gradio as gr
-    GRIDO_DISPONIVEL = True
-except ImportError as e:
-    print(f"❌ Gradio não disponível: {e}")
-    print("🔧 Usando interface alternativa...")
-    GRIDO_DISPONIVEL = False
-    
-    # Cria uma interface alternativa simples se gradio não estiver disponível
-    class SimpleInterface:
-        def __init__(self):
-            self.components = []
+        try:
+            # Busca por variações do termo 'auto'
+            termos_auto = ['auto', 'automóvel', 'carro', 'veículo', 'automovel']
+            mascara_auto = df['tipo_do_bem'].astype(str).str.lower().isin([t.lower() for t in termos_auto])
             
-        def launch(self, **kwargs):
-            print("Interface alternativa ativada")
-            print("Para usar a interface completa, instale Gradio corretamente")
-            # Simula a funcionalidade básica
-            while True:
-                print("\n" + "="*50)
-                print("SIMULADOR DE CONSÓRCIO AUTO")
-                print("="*50)
-                try:
-                    credito = float(input("Crédito Desejado (R$): ") or 30000)
-                    entrada = float(input("Entrada Desejada (R$): ") or 3000)
-                    parcela = float(input("Parcela Desejada (R$): ") or 500)
-                    
-                    print("\nAdministradoras disponíveis:")
-                    adm_options = get_administradoras_options()
-                    for i, adm in enumerate(adm_options, 1):
-                        print(f"{i}. {adm}")
-                    
-                    print("\nDigite os números das administradoras separados por vírgula (ou deixe em branco para todas):")
-                    adm_input = input("Administradoras: ")
-                    
-                    if adm_input.strip():
-                        adm_indices = [int(x.strip()) for x in adm_input.split(",")]
-                        administradoras = [adm_options[i-1] for i in adm_indices if 1 <= i <= len(adm_options)]
-                    else:
-                        administradoras = adm_options
-                    
-                    print(f"\n🔍 Buscando combinações...")
-                    resultado = ajustar_e_buscar(credito, entrada, parcela, administradoras)
-                    
-                    print("\n" + "="*50)
-                    print("RESULTADOS:")
-                    print("="*50)
-                    print(resultado)
-                    
-                    continuar = input("\nDeseja fazer nova busca? (s/n): ")
-                    if continuar.lower() != 's':
-                        break
-                        
-                except (ValueError, KeyboardInterrupt):
-                    print("\nOperação cancelada.")
-                    break
-
-if GRIDO_DISPONIVEL:
-    # 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
-        )
+            if mascara_auto.any():
+                df_filtrado = df[mascara_auto]
+            else:
+                df_filtrado = df
+            
+            if 'administradora' in df_filtrado.columns:
+                # Extrai as administradoras e mantém o formato ORIGINAL
+                adm_list = df_filtrado['administradora'].dropna().unique()
+                adm_list = [str(adm).strip() for adm in adm_list if str(adm).strip()]
+                
+                # Remove duplicatas (considerando case insensitive)
+                unique_adms = []
+                seen = set()
+                for adm in adm_list:
+                    adm_lower = adm.lower()
+                    if adm_lower not in seen:
+                        seen.add(adm_lower)
+                        unique_adms.append(adm)
+                
+                # Ordena alfabeticamente
+                unique_adms.sort()
+                print(f"✅ Administradoras carregadas: {len(unique_adms)}")
+                return unique_adms
+                
+        except Exception as e:
+            print(f"❌ Erro ao carregar administradoras: {str(e)}")
+    
+    # Fallback se algo der errado
+    fallback = ["Ademicon", "Banco do Brasil", "Bancorbrás", "Banrisul", "Bradesco", 
+                "Caixa", "Canopus", "Embracon", "HS", "Itaú", "Santander"]
+    print(f"⚠️ Usando lista fallback: {fallback}")
+    return fallback
+
+# Criando a interface Gradio COM AS ADMINISTRADORAS CORRETAS
+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)
+
+    # Carrega as opções de administradoras
+    admin_opcoes = get_administradoras_options()
+    
+    administradoras_multiselect = gr.CheckboxGroup(
+        label="Filtrar por Administradoras",
+        choices=admin_opcoes,
+        value=admin_opcoes[:3] if len(admin_opcoes) >= 3 else admin_opcoes,
+        info=f"Total de {len(admin_opcoes)} administradoras disponíveis"
+    )
 
-        submit_btn = gr.Button("🔍 Buscar Combinações", variant="primary")
+    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...")
+    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
-        )
+    submit_btn.click(
+        fn=ajustar_e_buscar,
+        inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect],
+        outputs=output_text,
+        api_name="ajustar_e_buscar"
+    )
 
-        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)
-else:
-    # Usa interface alternativa
-    if __name__ == "__main__":
-        interface = SimpleInterface()
-        interface.launch()
+    # Adiciona informação sobre as administradoras
+    gr.Markdown(f"""
+    ### 📋 Administradoras disponíveis:
+    {', '.join(admin_opcoes)}
+    
+    ---
+    **Desenvolvido para auxiliar na busca por cotas de consórcio ideais.**
+    """)
+
+# Inicia o aplicativo Gradio
+if __name__ == "__main__":
+    print("🌐 Iniciando servidor Gradio...")
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860,
+        debug=True,
+        show_error=True
+    )