Remove Gradio legado e automatiza release portátil

.github/workflows/build-windows-portable.yml

@@ -40,18 +40,8 @@ jobs:
         shell: pwsh
         run: ./build/windows/smoke_test_portable.ps1
 
-      - name: Archive portable folder
-        shell: pwsh
-        run: |
-          if (Test-Path "dist/MesaFrame-portable.zip") {
-            Remove-Item "dist/MesaFrame-portable.zip" -Force
-          }
-          Compress-Archive -Path "dist/MesaFrame/*" -DestinationPath "dist/MesaFrame-portable.zip"
-
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
           name: MesaFrame-portable
-          path: |
-            dist/MesaFrame
-            dist/MesaFrame-portable.zip
+          path: dist/MesaFrame-portable.zip

backend/app/core/elaboracao/app.py

@@ -1,1908 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-app.py - Interface Gradio para elaboração de modelos estatísticos.
-
-Contém criar_aba() (construção de UI + event wiring) e callbacks auxiliares pequenos.
-Lógica de negócio delegada a módulos: modelo.py, carregamento.py, outliers.py, formatadores.py.
-"""
-
-import gradio as gr
-import pandas as pd
-import os
-import json
-
-from app.runtime_config import resolve_core_path
-
-_avaliadores_path = resolve_core_path("elaboracao", "avaliadores.json")
-with open(_avaliadores_path, encoding="utf-8") as _f:
-    _avaliadores_raw = json.load(_f)
-_avaliadores_lista = _avaliadores_raw.get("avaliadores", [])
-_avaliadores_nomes = [a["nome_completo"] for a in _avaliadores_lista]
-_avaliadores_dict = {a["nome_completo"]: a for a in _avaliadores_lista}
-
-# Módulos locais — lógica de negócio
-from .core import (
-    obter_colunas_numericas,
-    exportar_base_csv,
-    TRANSFORMACOES,
-)
-from .charts import criar_mapa
-from .csv_export import exportar_dataframe_csv_temporario
-
-# Módulos locais — formatação
-from .formatadores import TITULO, carregar_css, criar_header_secao
-
-# Módulos locais — callbacks de domínio
-from .modelo import (
-    MAX_VARS_X,
-    ao_mudar_tipo_grafico,
-    ao_mudar_y_sem_estatisticas,
-    aplicar_selecao_callback,
-    buscar_transformacoes_callback,
-    ajustar_modelo_callback,
-    _atualizar_campos_transformacoes_com_flag,
-    adotar_sugestao,
-    exportar_modelo_callback,
-    popular_campos_avaliacao_callback,
-    avaliar_imovel_callback,
-    limpar_avaliacoes_callback,
-    excluir_avaliacao_callback,
-    atualizar_base_avaliacao_callback,
-    exportar_avaliacoes_excel_callback,
-    atualizar_interativo_dicotomicas,
-    popular_dicotomicas_callback,
-)
-from .carregamento import (
-    ao_carregar_arquivo,
-    confirmar_aba_callback,
-    limpar_historico_callback,
-)
-from .geocodificacao import (
-    padronizar_coords,
-    geocodificar,
-    aplicar_correcoes_e_regeodificar,
-    formatar_status_geocodificacao,
-    preparar_display_falhas,
-)
-from .outliers import (
-    aplicar_filtros_callback,
-    adicionar_filtro_callback,
-    remover_ultimo_filtro_callback,
-    limpar_filtros_callback,
-    reiniciar_iteracao_callback,
-    atualizar_resumo_outliers,
-)
-
-
-# ============================================================
-# CALLBACKS AUXILIARES (pequenos, diretamente ligados ao event wiring)
-# ============================================================
-
-def download_tabela_callback(df, prefixo="tabela"):
-    """Callback genérico para download de DataFrame como CSV."""
-    if df is None:
-        return gr.update(value=None, visible=False)
-
-    try:
-        if isinstance(df, pd.DataFrame):
-            caminho = exportar_dataframe_csv_temporario(df, prefixo=prefixo, incluir_indice=True)
-            if not caminho:
-                return gr.update(value=None, visible=False)
-            return gr.update(value=caminho, visible=True)
-        else:
-            return gr.update(value=None, visible=False)
-    except Exception as e:
-        print(f"Erro ao exportar tabela: {e}")
-        return gr.update(value=None, visible=False)
-
-
-def _extrair_var_mapa(var_mapa):
-    """Retorna None se for 'Visualização Padrão' ou vazio, senão retorna o nome da variável."""
-    if not var_mapa or var_mapa == "Visualização Padrão":
-        return None
-    return var_mapa
-
-
-def ao_clicar_tabela(df, var_mapa, evt: gr.SelectData):
-    """Callback quando clica em linha da tabela."""
-    if df is None or evt is None:
-        return "<p>Carregue dados para ver o mapa.</p>"
-
-    # Pega o índice da linha clicada
-    indice = evt.index[0] + 1  # Ajusta para índice baseado em 1
-
-    return criar_mapa(df, indice_destacado=indice, tamanho_col=_extrair_var_mapa(var_mapa))
-
-
-def atualizar_mapa_callback(df_filtrado, df_original, var_mapa):
-    """Callback quando a variável de dimensionamento do mapa é alterada."""
-    df = df_filtrado if df_filtrado is not None else df_original
-    if df is None:
-        return "<p>Carregue dados para ver o mapa.</p>"
-    return criar_mapa(df, tamanho_col=_extrair_var_mapa(var_mapa))
-
-
-MAX_FALHAS_GEO = 20  # Slots pré-alocados para correção individual de falhas de geocodificação
-
-# ============================================================
-# CALLBACKS DE RESOLUÇÃO DE COORDENADAS (Seção 1 — painel lat/lon)
-# ============================================================
-
-def _revelar_secao_2(df, mapa):
-    """Retorna os 9 valores comuns a todos os callbacks de resolução de coords."""
-    from datetime import datetime, timezone, timedelta
-    gmt_minus_3 = timezone(timedelta(hours=-3))
-    ts = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
-    return (
-        df,                                                                        # estado_df
-        df,                                                                        # estado_df_filtrado
-        mapa,                                                                      # mapa_html
-        gr.update(visible=False),                                                  # row_coords_panel
-        gr.update(visible=True, value=criar_header_secao(2, "Visualizar Dados", ts)),  # header_secao_2
-        gr.update(visible=True, open=True),                                        # accordion_secao_2
-        gr.update(visible=True),                                                   # header_secao_3
-        gr.update(visible=True, open=True),                                        # accordion_secao_3
-    )
-
-
-def confirmar_mapeamento_callback(df, col_lat, col_lon):
-    """Opção 1: copia col_lat → 'lat' e col_lon → 'lon', libera Seção 2.
-
-    CONTRACT: 10 itens — html_erro_mapeamento + 8 de _revelar_secao_2 + status
-
-    Valida 4 aspectos antes de aceitar as colunas:
-      1. Conversibilidade numérica (≥50% dos valores)
-      2. Limites teóricos (lat −90/+90, lon −180/+180, ≥80%)
-      3. Inversão entre colunas (lat parece lon e vice-versa)
-      4. Casas decimais (coordenadas geográficas raramente são inteiros exatos)
-    """
-    def _erro_mapeamento(linhas_html):
-        html = (
-            '<div style="color:#c0392b;margin-top:6px;padding:8px 12px;'
-            'background:#fdf2f2;border-radius:6px;border-left:3px solid #c0392b">'
-            '<strong>⚠ Diagnóstico das colunas selecionadas:</strong><br>'
-            + linhas_html +
-            '</div>'
-        )
-        return (
-            gr.update(value=html),
-            gr.update(), gr.update(), gr.update(),
-            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
-            gr.update(),
-        )
-
-    if df is None or not col_lat or not col_lon:
-        return _erro_mapeamento("Selecione as colunas de latitude e longitude antes de confirmar.")
-
-    n_total = len(df)
-    if n_total == 0:
-        return _erro_mapeamento("O DataFrame está vazio.")
-
-    # Aspecto 1 — Conversibilidade numérica
-    lat_num = pd.to_numeric(df[col_lat], errors="coerce")
-    lon_num = pd.to_numeric(df[col_lon], errors="coerce")
-    lat_vals = lat_num.dropna()
-    lon_vals = lon_num.dropna()
-    lat_conv = len(lat_vals) / n_total
-    lon_conv = len(lon_vals) / n_total
-
-    erros_conv = []
-    if lat_conv < 0.5:
-        erros_conv.append(
-            f"• <strong>{col_lat}</strong>: apenas {lat_conv:.0%} dos valores são numéricos "
-            f"— a coluna provavelmente não contém coordenadas."
-        )
-    if lon_conv < 0.5:
-        erros_conv.append(
-            f"• <strong>{col_lon}</strong>: apenas {lon_conv:.0%} dos valores são numéricos "
-            f"— a coluna provavelmente não contém coordenadas."
-        )
-    if erros_conv:
-        return _erro_mapeamento("<br>".join(erros_conv))
-
-    # Aspecto 2 — Limites teóricos
-    lat_in_range = ((lat_vals >= -90) & (lat_vals <= 90)).mean()
-    lon_in_range = ((lon_vals >= -180) & (lon_vals <= 180)).mean()
-
-    # Aspecto 3 — Inversão de colunas
-    lat_in_lon_range = ((lat_vals >= -180) & (lat_vals <= 180)).mean()
-    lon_in_lat_range = ((lon_vals >= -90) & (lon_vals <= 90)).mean()
-    inversao = lat_in_range < 0.5 and lat_in_lon_range > 0.8 and lon_in_lat_range > 0.8
-
-    # Aspecto 4 — Casas decimais
-    lat_tem_decimais = (lat_vals % 1 != 0).mean() if len(lat_vals) > 0 else 0.0
-    lon_tem_decimais = (lon_vals % 1 != 0).mean() if len(lon_vals) > 0 else 0.0
-
-    linhas = []
-
-    if inversao:
-        linhas.append(
-            f"• As colunas parecem estar <strong>invertidas</strong>: "
-            f"<strong>{col_lat}</strong> tem {1 - lat_in_range:.0%} dos valores fora de −90 a +90 "
-            f"(fora do intervalo de latitude), mas dentro de −180 a +180 (intervalo de longitude). "
-            f"<strong>{col_lon}</strong> tem {lon_in_lat_range:.0%} dos valores em −90 a +90 "
-            f"(faixa típica de latitude). Tente trocar as colunas."
-        )
-    else:
-        if lat_in_range < 0.8:
-            linhas.append(
-                f"• <strong>{col_lat}</strong>: apenas {lat_in_range:.0%} dos valores estão "
-                f"em −90 a +90 (esperado para latitude)."
-            )
-        if lon_in_range < 0.8:
-            linhas.append(
-                f"• <strong>{col_lon}</strong>: apenas {lon_in_range:.0%} dos valores estão "
-                f"em −180 a +180 (esperado para longitude)."
-            )
-
-    # Aspecto 4 só é avaliado se não há outros problemas (seria ruído adicional)
-    if not linhas:
-        if lat_tem_decimais < 0.1:
-            linhas.append(
-                f"• <strong>{col_lat}</strong>: {lat_tem_decimais:.0%} dos valores têm casas decimais "
-                f"— coordenadas geográficas normalmente são valores de ponto flutuante, não inteiros exatos."
-            )
-        if lon_tem_decimais < 0.1:
-            linhas.append(
-                f"• <strong>{col_lon}</strong>: {lon_tem_decimais:.0%} dos valores têm casas decimais "
-                f"— coordenadas geográficas normalmente são valores de ponto flutuante, não inteiros exatos."
-            )
-
-    if linhas:
-        return _erro_mapeamento("<br>".join(linhas))
-
-    df_novo = padronizar_coords(df, col_lat, col_lon)
-    mapa = criar_mapa(df_novo)
-    return (
-        gr.update(value=""),  # html_erro_mapeamento — limpar
-    ) + _revelar_secao_2(df_novo, mapa) + ("Coordenadas mapeadas. Seção 2 liberada.",)
-
-
-def geocodificar_callback(df, col_cdlog, col_num, auto_200):
-    """Opção 3: executa geocodificação por interpolação em eixos.
-
-    CONTRACT: 65 itens —
-      estado_geo_temp, estado_df_falhas, html_geo_status,
-      20×falha_rows, 20×falha_htmls, 20×falha_inputs,
-      btn_aplicar_correcoes_geo, btn_usar_coords_geo
-    """
-    N = MAX_FALHAS_GEO
-    _no_slots = (
-        *[gr.update(visible=False)] * N,
-        *[gr.update(value="")] * N,
-        *[gr.update(value=None)] * N,
-    )
-
-    if df is None or not col_cdlog or not col_num:
-        return (
-            None, None,
-            "<p>Selecione as colunas CDLOG e Número Predial.</p>",
-            *_no_slots,
-            gr.update(visible=False), gr.update(visible=False),
-        )
-    try:
-        df_resultado, df_falhas, ajustados = geocodificar(df, col_cdlog, col_num, auto_200)
-    except RuntimeError as e:
-        return (
-            None, None,
-            f'<div style="color:red;padding:8px">{e}</div>',
-            *_no_slots,
-            gr.update(visible=False), gr.update(visible=False),
-        )
-
-    html_status = formatar_status_geocodificacao(df_resultado, df_falhas, ajustados)
-    n_falhas = len(df_falhas)
-    tem_coords = df_resultado["lat"].notna().any() if "lat" in df_resultado.columns else False
-    completo = n_falhas == 0 and tem_coords
-
-    if n_falhas > N:
-        html_status += (
-            f'<div style="color:#c0392b;margin-top:6px">⚠ {n_falhas} falhas excedem o limite '
-            f'de {N} correções manuais. Corrija os endereços na planilha-fonte e recarregue.</div>'
-        )
-        return (
-            df_resultado, None,
-            html_status,
-            *_no_slots,
-            gr.update(visible=False), gr.update(visible=False),
-        )
-
-    # Monta atualizações para os N slots
-    row_updates, html_updates, num_updates = [], [], []
-    for i in range(N):
-        if i < n_falhas:
-            row = df_falhas.iloc[i]
-            sugestoes = row.get("sugestoes", "")
-            linha = row["_idx"]
-            row_updates.append(gr.update(visible=True))
-            html_updates.append(gr.update(value=(
-                f'<div style="padding:4px 8px;background:#fff8f0;border-left:3px solid #f39c12;'
-                f'border-radius:4px;font-size:0.9em">'
-                f'<strong>Linha {linha}</strong> · CDLOG {row["cdlog"]} · '
-                f'Nº atual: <strong>{row["numero_atual"]}</strong> · {row["motivo"]}'
-                + (f'<br><span style="color:#555">Sugestões: {sugestoes}</span>' if sugestoes else '')
-                + '</div>'
-            )))
-            num_updates.append(gr.update(value=None, label=f"Nº Corrigido (linha {linha})"))
-        else:
-            row_updates.append(gr.update(visible=False))
-            html_updates.append(gr.update(value=""))
-            num_updates.append(gr.update(value=None))
-
-    return (
-        df_resultado,                                    # estado_geo_temp
-        df_falhas if n_falhas > 0 else None,             # estado_df_falhas
-        html_status,                                     # html_geo_status
-        *row_updates,                                    # 20 falha_rows
-        *html_updates,                                   # 20 falha_htmls
-        *num_updates,                                    # 20 falha_inputs
-        gr.update(visible=n_falhas > 0),                 # btn_aplicar_correcoes_geo
-        gr.update(visible=completo),                     # btn_usar_coords_geo
-    )
-
-
-def aplicar_correcoes_geo_callback(df_original, df_falhas, *args):
-    """Opção 3: aplica correções manuais e re-geocodifica.
-
-    CONTRACT: inputs = estado_geo_temp (1) + estado_df_falhas (1) + 20 falha_inputs + 3 params = 25.
-    CONTRACT: 65 itens retornados (mesmo formato de geocodificar_callback).
-    """
-    N = MAX_FALHAS_GEO
-    correcoes_vals = list(args[:N])
-    col_cdlog, col_num, auto_200 = args[N], args[N + 1], args[N + 2]
-
-    _no_slots = (
-        *[gr.update(visible=False)] * N,
-        *[gr.update(value="")] * N,
-        *[gr.update(value=None)] * N,
-    )
-
-    if df_original is None or df_falhas is None or not col_cdlog or not col_num:
-        return (
-            None, None,
-            "<p>Sem dados para processar.</p>",
-            *_no_slots,
-            gr.update(visible=False), gr.update(visible=False),
-        )
-
-    # Monta coluna "numero_corrigido" a partir dos valores dos gr.Number
-    df_falhas_fmt = df_falhas.copy()
-    num_corrigidos = []
-    for i, val in enumerate(correcoes_vals[:len(df_falhas_fmt)]):
-        if val is not None and not (isinstance(val, float) and pd.isna(val)):
-            num_corrigidos.append(str(int(val)))
-        else:
-            num_corrigidos.append("")
-    # Preenche com "" os slots além do tamanho real de df_falhas
-    num_corrigidos += [""] * max(0, len(df_falhas_fmt) - len(num_corrigidos))
-    df_falhas_fmt["numero_corrigido"] = num_corrigidos
-
-    try:
-        df_resultado, df_falhas_novas, ajustados, manuais = aplicar_correcoes_e_regeodificar(
-            df_original, df_falhas_fmt, col_cdlog, col_num, auto_200
-        )
-    except RuntimeError as e:
-        return (
-            None, None,
-            f'<div style="color:red;padding:8px">{e}</div>',
-            *_no_slots,
-            gr.update(visible=False), gr.update(visible=False),
-        )
-
-    html_status = formatar_status_geocodificacao(df_resultado, df_falhas_novas, ajustados, manuais)
-    n_falhas = len(df_falhas_novas)
-    tem_coords = df_resultado["lat"].notna().any() if "lat" in df_resultado.columns else False
-    completo = n_falhas == 0 and tem_coords
-
-    if n_falhas > N:
-        html_status += (
-            f'<div style="color:#c0392b;margin-top:6px">⚠ {n_falhas} falhas excedem o limite '
-            f'de {N} correções manuais. Corrija os endereços na planilha-fonte e recarregue.</div>'
-        )
-        return (
-            df_resultado, None,
-            html_status,
-            *_no_slots,
-            gr.update(visible=False), gr.update(visible=False),
-        )
-
-    row_updates, html_updates, num_updates = [], [], []
-    for i in range(N):
-        if i < n_falhas:
-            row = df_falhas_novas.iloc[i]
-            sugestoes = row.get("sugestoes", "")
-            linha = row["_idx"]
-            row_updates.append(gr.update(visible=True))
-            html_updates.append(gr.update(value=(
-                f'<div style="padding:4px 8px;background:#fff8f0;border-left:3px solid #f39c12;'
-                f'border-radius:4px;font-size:0.9em">'
-                f'<strong>Linha {linha}</strong> · CDLOG {row["cdlog"]} · '
-                f'Nº atual: <strong>{row["numero_atual"]}</strong> · {row["motivo"]}'
-                + (f'<br><span style="color:#555">Sugestões: {sugestoes}</span>' if sugestoes else '')
-                + '</div>'
-            )))
-            num_updates.append(gr.update(value=None, label=f"Nº Corrigido (linha {linha})"))
-        else:
-            row_updates.append(gr.update(visible=False))
-            html_updates.append(gr.update(value=""))
-            num_updates.append(gr.update(value=None))
-
-    return (
-        df_resultado,
-        df_falhas_novas if n_falhas > 0 else None,
-        html_status,
-        *row_updates,
-        *html_updates,
-        *num_updates,
-        gr.update(visible=n_falhas > 0),             # btn_aplicar_correcoes_geo
-        gr.update(visible=completo),                  # btn_usar_coords_geo
-    )
-
-
-def confirmar_geocodificacao_callback(df_geo):
-    """Opção 3: confirma uso das coords geocodificadas e libera Seção 2."""
-    if df_geo is None:
-        return (
-            gr.update(), gr.update(), gr.update(),
-            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
-            "Sem dados geocodificados.",
-        )
-    mapa = criar_mapa(df_geo)
-    return _revelar_secao_2(df_geo, mapa) + ("Geocodificação concluída. Seção 2 liberada.",)
-
-
-def confirmar_sem_coords_callback(df):
-    """Prossegue para Seção 2 sem coordenadas completas (decisão explícita do usuário)."""
-    if df is None:
-        return (
-            gr.update(), gr.update(), gr.update(),
-            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
-            "Sem dados carregados.",
-        )
-    mapa = criar_mapa(df)
-    return _revelar_secao_2(df, mapa) + ("Seção 2 liberada sem coordenadas completas.",)
-
-
-# ============================================================
-# INTERFACE GRADIO
-# ============================================================
-
-def criar_aba():
-    """Cria conteúdo da aba de elaboração (sem wrapper gr.Blocks)."""
-
-    # Estados
-    estado_df = gr.State(None)
-    estado_modelo = gr.State(None)
-    estado_estatisticas = gr.State(None)
-    estado_outliers_anteriores = gr.State([])  # Lista de índices excluídos em iterações anteriores
-    estado_iteracao = gr.State(1)  # Contador de iterações
-    estado_avaliacoes = gr.State([])  # Lista de avaliações acumuladas
-
-    # ========================================
-    # SEÇÃO 1: IMPORTAR DADOS (sempre visível e aberta)
-    # ========================================
-    # Estado para armazenar o arquivo temporariamente (usado quando há múltiplas abas)
-    estado_arquivo_temp = gr.State(None)
-    estado_flag_carregamento = gr.State(False)
-    estado_geo_temp = gr.State(None)    # DataFrame durante geocodificação (antes de confirmar)
-    estado_df_falhas = gr.State(None)   # df_falhas mais recente (geocodificação)
-
-    header_secao_1 = gr.HTML(criar_header_secao(1, "Importar Dados"))
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        elem_classes="section-accordion"
-    ) as accordion_secao_1:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_1:
-            # Estado A: Upload (visível inicialmente)
-            with gr.Row(visible=True) as row_upload:
-                upload = gr.File(
-                    label="Carregar arquivo (Excel, CSV ou Modelo .dai)",
-                    scale=2
-                )
-                status = gr.Textbox(
-                    label="Status",
-                    interactive=False,
-                    scale=2
-                )
-
-            # Estado B: Seleção de aba — apenas para Excel multi-aba (oculto inicialmente)
-            with gr.Group(visible=False) as row_selecao_aba:
-                with gr.Row():
-                    dropdown_aba = gr.Dropdown(
-                        label="Selecionar Aba",
-                        choices=[],
-                        interactive=True,
-                    )
-                with gr.Row():
-                    btn_confirmar_aba = gr.Button("Selecionar Aba", variant="primary")
-
-            # Estado C: Pós-carregamento (oculto inicialmente)
-            with gr.Row(visible=False) as row_pos_carga:
-                with gr.Column(scale=5):
-                    html_nome_arquivo_carregado = gr.HTML(value="")
-                with gr.Column(scale=2):
-                    btn_reiniciar_app = gr.Button(
-                        "Reiniciar Aplicação",
-                        variant="danger"
-                    )
-                    html_aviso_reiniciar = gr.HTML(value=(
-                        '<div style="background-color:#fff3cd; border:1px solid #ffc107; '
-                        'border-radius:8px; padding:8px 12px; margin-top:8px; font-size:1em;">'
-                        '<strong>Atenção:</strong> Ao reiniciar, toda a aplicação MESA será '
-                        'recarregada e <strong>o conteúdo de todas as abas será perdido</strong>. '
-                        'Para iniciar uma nova sessão MESA sem perder o trabalho atual, '
-                        'abra uma <strong>nova aba do navegador</strong>.'
-                        '</div>'
-                    ))
-
-            # Estado D: Resolução de Coordenadas (oculto inicialmente)
-            with gr.Row(visible=False) as row_coords_panel:
-                with gr.Column():
-                    html_aviso_coords = gr.HTML(value="")
-
-                    # Tela de escolha (visível inicialmente)
-                    with gr.Row() as row_escolha_opcao:
-                        with gr.Column():
-                            with gr.Row():
-                                btn_escolher_mapear = gr.Button(
-                                    "Mapear colunas existentes para lat/lon",
-                                    variant="primary",
-                                    scale=10,
-                                )
-                                gr.HTML(
-                                    '<div style="align-self:center;text-align:center;'
-                                    'min-width:36px">'
-                                    '<span style="display:inline-block;font-size:0.75rem;'
-                                    'font-weight:600;color:#9ca3af;letter-spacing:0.05em;'
-                                    'text-transform:uppercase;background:#f3f4f6;'
-                                    'border-radius:999px;padding:3px 8px">ou</span>'
-                                    '</div>',
-                                    scale=1,
-                                )
-                                btn_escolher_geocodificar = gr.Button(
-                                    "Geocodificar automaticamente",
-                                    variant="primary",
-                                    scale=10,
-                                )
-                                gr.HTML(
-                                    '<div style="align-self:center;text-align:center;'
-                                    'min-width:36px">'
-                                    '<span style="display:inline-block;font-size:0.75rem;'
-                                    'font-weight:600;color:#9ca3af;letter-spacing:0.05em;'
-                                    'text-transform:uppercase;background:#f3f4f6;'
-                                    'border-radius:999px;padding:3px 8px">ou</span>'
-                                    '</div>',
-                                    scale=1,
-                                )
-                                btn_prosseguir_sem_coords = gr.Button(
-                                    "Prosseguir sem mapear coordenadas",
-                                    variant="primary",
-                                    scale=10,
-                                )
-                            with gr.Row(visible=False) as row_confirmacao_prosseguir:
-                                with gr.Column():
-                                    gr.HTML(
-                                        '<div style="background:#fff3cd;border:1px solid #ffc107;'
-                                        'border-radius:8px;padding:8px 12px;margin-top:4px">'
-                                        '<strong>Atenção:</strong> Funcionalidades dependentes de '
-                                        'geolocalização (mapa, análises espaciais) não funcionarão '
-                                        'para registros sem coordenadas ou apresentarão resultados '
-                                        'incompletos. Deseja prosseguir mesmo assim?'
-                                        '</div>'
-                                    )
-                                    btn_confirmar_prosseguir = gr.Button(
-                                        "Confirmar — prosseguir mesmo assim",
-                                        variant="stop",
-                                    )
-
-                    # Painel Mapear (oculto — botão Voltar no topo)
-                    with gr.Row(visible=False) as row_opcao_mapear:
-                        with gr.Column():
-                            btn_voltar_mapear = gr.Button("← Voltar", variant="secondary", size="sm")
-                            with gr.Row():
-                                dropdown_col_lat_manual = gr.Dropdown(
-                                    label="Coluna → lat",
-                                    choices=[],
-                                    interactive=True,
-                                )
-                                dropdown_col_lon_manual = gr.Dropdown(
-                                    label="Coluna → lon",
-                                    choices=[],
-                                    interactive=True,
-                                )
-                            html_erro_mapeamento = gr.HTML(value="")
-                            btn_confirmar_mapeamento = gr.Button(
-                                "Confirmar mapeamento",
-                                variant="primary",
-                            )
-
-                    # Painel Geocodificar (oculto — botão Voltar no topo)
-                    with gr.Row(visible=False) as row_opcao_geocodificar:
-                        with gr.Column():
-                            btn_voltar_geocodificar = gr.Button("← Voltar", variant="secondary", size="sm")
-                            with gr.Row():
-                                dropdown_cdlog_geo = gr.Dropdown(
-                                    label="Coluna CDLOG (código do logradouro)",
-                                    choices=[],
-                                    interactive=True,
-                                )
-                                dropdown_num_geo = gr.Dropdown(
-                                    label="Coluna Número Predial",
-                                    choices=[],
-                                    interactive=True,
-                                )
-                            checkbox_auto_200 = gr.Checkbox(
-                                label=(
-                                    "Permitir correção automática de ofício para números cuja "
-                                    "diferença do intervalo válido mais próximo seja ≤ 200"
-                                ),
-                                value=True,
-                            )
-                            btn_geocodificar = gr.Button("Geocodificar", variant="primary")
-                            html_geo_status = gr.HTML(value="<div style='min-height:40px'></div>")
-
-                            # 20 slots de correção individual (ocultos inicialmente)
-                            falha_rows = []
-                            falha_htmls = []
-                            falha_inputs = []
-                            for i in range(MAX_FALHAS_GEO):
-                                with gr.Row(visible=False) as _fr:
-                                    with gr.Column(scale=3):
-                                        _fh = gr.HTML(value="")
-                                    with gr.Column(scale=1):
-                                        _fi = gr.Number(label="Nº Corrigido", precision=0, value=None)
-                                falha_rows.append(_fr)
-                                falha_htmls.append(_fh)
-                                falha_inputs.append(_fi)
-
-                            btn_aplicar_correcoes_geo = gr.Button(
-                                "Aplicar correções e re-geocodificar",
-                                visible=False,
-                            )
-                            btn_usar_coords_geo = gr.Button(
-                                "Confirmar",
-                                variant="primary",
-                                visible=False,
-                            )
-
-
-    # ========================================
-    # SEÇÃO 2: VISUALIZAR DADOS (ativada ao carregar arquivo)
-    # ========================================
-    header_secao_2 = gr.HTML(criar_header_secao(2, "Visualizar Dados"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_2:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_2:
-            with gr.Accordion("Outliers Excluídos", open=True, visible=False) as accordion_outliers_anteriores:
-                html_outliers_anteriores = gr.HTML(value="")
-                btn_limpar_historico = gr.Button("Limpar Histórico e Reiniciar do Zero", variant="secondary")
-
-            with gr.Accordion("Dados de Mercado", open=True):
-                tabela_dados = gr.Dataframe(
-                    label="",
-                    interactive=False,
-                    max_height=400
-                )
-                with gr.Row():
-                    btn_download_dados = gr.Button("Baixar Dados (CSV)", variant="secondary", size="sm")
-                    download_dados_file = gr.File(label="", visible=False)
-
-            dropdown_mapa_var = gr.Dropdown(
-                label="Variável para dimensionar pontos no mapa",
-                choices=["Visualização Padrão"],
-                value="Visualização Padrão",
-                interactive=True,
-                allow_custom_value=False
-            )
-
-            with gr.Accordion("Mapa", open=True):
-                mapa_html = gr.HTML(
-                    value="<p>Carregue dados para ver o mapa.</p>",
-                    label=""
-                )
-
-    # ========================================
-    # SEÇÃO 3: SELECIONAR VARIÁVEL DEPENDENTE (ativada ao carregar arquivo)
-    # ========================================
-    header_secao_3 = gr.HTML(criar_header_secao(3, "Selecionar Variável Dependente"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_3:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_3:
-            with gr.Row():
-                dropdown_y = gr.Dropdown(
-                    label="Variável Dependente (y)",
-                    choices=[],
-                    interactive=True,
-                    scale=2
-                )
-            with gr.Row():
-                btn_aplicar_y = gr.Button("Aplicar Seleção", variant="primary", scale=1)
-
-    # ========================================
-    # SEÇÃO 4: SELECIONAR VARIÁVEIS INDEPENDENTES (ativada ao selecionar Y)
-    # ========================================
-    header_secao_4 = gr.HTML(criar_header_secao(4, "Selecionar Variáveis Independentes"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_4:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_4:
-            with gr.Row(elem_classes="checkbox-selecionar-todos"):
-                checkbox_selecionar_todos = gr.Checkbox(
-                    label="Marcar ou desmarcar todas as variáveis",
-                    value=True,
-                    interactive=True
-                )
-            with gr.Row():
-                checkboxes_x = gr.CheckboxGroup(
-                    label="Variáveis Independentes (X)",
-                    choices=[],
-                    interactive=True
-                )
-            with gr.Row():
-                checkboxes_dicotomicas = gr.CheckboxGroup(
-                    label="Variáveis Dicotômicas (0/1)",
-                    choices=[], value=[], visible=False, interactive=True,
-                    info="Transformação fixa em (x). Avaliação: apenas 0 ou 1."
-                )
-            with gr.Row():
-                checkboxes_codigo_alocado = gr.CheckboxGroup(
-                    label="Variáveis Categóricas Codificadas",
-                    choices=[], value=[], visible=False, interactive=True,
-                    info="Transformação livre. Avaliação: apenas inteiros no intervalo observado."
-                )
-            with gr.Row():
-                checkboxes_percentuais = gr.CheckboxGroup(
-                    label="Variáveis Percentuais (0 a 1)",
-                    choices=[], value=[], visible=False, interactive=True,
-                    info="Transformação fixa em (x). Avaliação: apenas valores entre 0 e 1."
-                )
-            with gr.Row():
-                btn_aplicar_selecao_x = gr.Button("Aplicar Seleção", variant="primary", scale=1)
-            html_aviso_multicolinearidade = gr.HTML("", visible=False)
-
-    # Estados para outliers (usados na seção de Análise de Outliers após o modelo)
-    estado_metricas = gr.State(None)
-    estado_df_filtrado = gr.State(None)
-
-    # ========================================
-    # SEÇÃO 5: ESTATÍSTICAS DAS VARIÁVEIS SELECIONADAS (ativada por Aplicar Seleção)
-    # ========================================
-    header_secao_5 = gr.HTML(criar_header_secao(5, "Estat��sticas das Variáveis Selecionadas"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_5:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_5:
-            tabela_estatisticas = gr.Dataframe(
-                label="",
-                interactive=False,
-                value=None,
-                wrap=True
-            )
-            with gr.Row():
-                btn_download_estatisticas = gr.Button("Baixar Estatísticas (CSV)", variant="secondary", size="sm")
-                download_estatisticas_file = gr.File(label="", visible=False)
-
-    # ========================================
-    # SEÇÃO 6: TESTE DE MICRONUMEROSIDADE (ativada por Aplicar Seleção)
-    # ========================================
-    header_secao_6 = gr.HTML(criar_header_secao(6, "Teste de Micronumerosidade"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_6:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_6:
-            html_micronumerosidade = gr.HTML(value="")
-
-    # ========================================
-    # SEÇÃO 7: GRÁFICOS DE DISPERSÃO (ativada por Aplicar Seleção)
-    # ========================================
-    header_secao_7 = gr.HTML(criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_7:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_7:
-            plot_dispersao = gr.Plot(label="")
-
-    # ========================================
-    # SEÇÃO 8: TRANSFORMAÇÕES SUGERIDAS (ativada por Aplicar Seleção)
-    # ========================================
-    # Estado para armazenar resultados da busca
-    estado_resultados_busca = gr.State([])
-
-    header_secao_8 = gr.HTML(criar_header_secao(8, "Transformações Sugeridas"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_8:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_8:
-            with gr.Row():
-                slider_grau_coef = gr.Radio(
-                    choices=[("Sem enquadramento", 0), ("Grau I (p≤30%)", 1), ("Grau II (p≤20%)", 2), ("Grau III (p≤10%)", 3)],
-                    value=3,
-                    label="Grau mínimo de significância dos coeficientes",
-                    type="value"
-                )
-                slider_grau_f = gr.Radio(
-                    choices=[("Sem enquadramento", 0), ("Grau I (α=5%)", 1), ("Grau II (α=2%)", 2), ("Grau III (α=1%)", 3)],
-                    value=3,
-                    label="Grau mínimo do Teste F",
-                    type="value"
-                )
-            busca_html = gr.HTML(value="")
-
-    # ========================================
-    # SEÇÃO 9: APLICAÇÃO DAS TRANSFORMAÇÕES (ativada por Aplicar Seleção)
-    # ========================================
-    header_secao_9 = gr.HTML(criar_header_secao(9, "Aplicação das Transformações"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_9:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_9:
-            # Área destacada para botões de adoção
-            gr.HTML("""
-                <div class="adotar-header">
-                    <span class="adotar-titulo">Adote uma das otimizações de transformação sugeridas na seção anterior</span>
-                </div>
-            """)
-            with gr.Row(elem_classes="adotar-row"):
-                btn_adotar_1 = gr.Button("✓ Adotar #1", visible=False, elem_classes="btn-adotar", variant="primary")
-                btn_adotar_2 = gr.Button("✓ Adotar #2", visible=False, elem_classes="btn-adotar", variant="primary")
-                btn_adotar_3 = gr.Button("✓ Adotar #3", visible=False, elem_classes="btn-adotar", variant="primary")
-                btn_adotar_4 = gr.Button("✓ Adotar #4", visible=False, elem_classes="btn-adotar", variant="primary")
-                btn_adotar_5 = gr.Button("✓ Adotar #5", visible=False, elem_classes="btn-adotar", variant="primary")
-
-            gr.HTML("<div class='adotar-separator'><span>ou configure manualmente</span></div>")
-
-            gr.Markdown("*Selecione a transformação para cada variável (dicotômicas ficam fixas em (x))*", elem_classes="transf-instrucao")
-
-            # Cards: os 3 gr.Row são transparentes (display:contents via CSS) e fluem
-            # num único container flex (.transf-all-cards), garantindo distribuição uniforme
-            # 3 linhas × 8 = 24 slots; apenas os 20 primeiros são rastreados
-            # Card Y fica antes dos cards X (mesmo container flex)
-            transf_x_rows = []
-            transf_x_columns = []
-            transf_x_labels = []
-            transf_x_dropdowns = []
-
-            with gr.Column(elem_classes="transf-all-cards"):
-                # Card da variável dependente Y (borda azul, label dinâmico com nome + "(Y)")
-                with gr.Row(visible=False, elem_classes="transf-cards-row") as transf_y_row:
-                    with gr.Column(scale=1, min_width=110, elem_classes="transf-card transf-card-y", visible=False) as transf_y_col:
-                        transf_y_label = gr.HTML(value="", visible=False, elem_classes="transf-card-label")
-                        transformacao_y = gr.Dropdown(
-                            choices=TRANSFORMACOES,
-                            value="(x)",
-                            label="",
-                            show_label=False,
-                            interactive=True,
-                            visible=True,
-                        )
-
-                for i in range((MAX_VARS_X + 7) // 8):  # 3 rows
-                    row = gr.Row(visible=False, elem_classes="transf-cards-row")
-                    with row:
-                        for j in range(8):
-                            k = i * 8 + j
-                            col = gr.Column(scale=1, min_width=110, elem_classes="transf-card", visible=False)
-                            with col:
-                                label = gr.HTML(value="", visible=False, elem_classes="transf-card-label")
-                                dropdown = gr.Dropdown(
-                                    choices=TRANSFORMACOES,
-                                    value="(x)",
-                                    label="",
-                                    show_label=False,
-                                    interactive=True,
-                                    visible=False,
-                                )
-                            if k < MAX_VARS_X:
-                                transf_x_columns.append(col)
-                                transf_x_labels.append(label)
-                                transf_x_dropdowns.append(dropdown)
-                    transf_x_rows.append(row)
-
-            with gr.Row():
-                btn_ajustar = gr.Button("Aplicar transformações e ajustar modelo", variant="primary", scale=1)
-
-    # ========================================
-    # SEÇÃO 10: GRÁFICOS DE DISPERSÃO (VARIÁVEIS TRANSFORMADAS) (ativada por Ajustar Modelo)
-    # ========================================
-    header_secao_10 = gr.HTML(criar_header_secao(10, "Gráficos de Dispersão (Variáveis Transformadas)"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_10:
-        with gr.Column(elem_classes="section-content") as conteudo_secao_10:
-            dropdown_tipo_grafico_dispersao = gr.Dropdown(
-                choices=[
-                    "Variáveis Independentes Transformadas X Variável Dependente Transformada",
-                    "Variáveis Independentes Transformadas X Resíduo Padronizado"
-                ],
-                value="Variáveis Independentes Transformadas X Variável Dependente Transformada",
-                label="Tipo de Gráfico",
-                interactive=True,
-                visible=True,
-                elem_id="dropdown_dispersao"
-            )
-            plot_dispersao_transf = gr.Plot(label="", visible=True)
-
-    # ========================================
-    # SEÇÃO 11: DIAGNÓSTICO DE MODELO (ativada por Ajustar Modelo)
-    # ========================================
-    header_secao_11 = gr.HTML(criar_header_secao(11, "Diagnóstico de Modelo"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_11:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_11:
-            diagnosticos_html = gr.HTML(value="")
-
-            with gr.Row():
-                with gr.Accordion("Tabela de Coeficientes", open=True):
-                    tabela_coef = gr.Dataframe(
-                        label="",
-                        interactive=False,
-                        max_height=400
-                    )
-                    with gr.Row():
-                        btn_download_coef = gr.Button("Baixar Coeficientes (CSV)", variant="secondary", size="sm")
-                        download_coef_file = gr.File(label="", visible=False)
-
-                with gr.Accordion("Valores Observados vs Calculados", open=True):
-                    tabela_obs_calc = gr.Dataframe(
-                        label="",
-                        interactive=False,
-                        max_height=400
-                    )
-                    with gr.Row():
-                        btn_download_obs_calc = gr.Button("Baixar Obs vs Calc (CSV)", variant="secondary", size="sm")
-                        download_obs_calc_file = gr.File(label="", visible=False)
-
-    # ========================================
-    # SEÇÃO 12: GRÁFICOS DE DIAGNÓSTICO DO MODELO (ativada por Ajustar Modelo)
-    # ========================================
-    header_secao_12 = gr.HTML(criar_header_secao(12, "Gráficos de Diagnóstico do Modelo"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_12:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_12:
-            with gr.Row():
-                plot_obs_calc = gr.Plot(label="Observados vs Calculados")
-                plot_residuos = gr.Plot(label="Resíduos")
-
-            with gr.Row():
-                plot_hist = gr.Plot(label="Histograma dos Resíduos")
-                plot_cook = gr.Plot(label="Distância de Cook")
-
-            with gr.Row():
-                plot_corr = gr.Plot(label="Matriz de Correlação")
-
-    # ========================================
-    # SEÇÃO 13: ANALISAR OUTLIERS (ativada por Ajustar Modelo)
-    # ========================================
-    # Estado para armazenar o número de filtros visíveis
-    estado_n_filtros = gr.State(2)  # Começa com 2 filtros padrão
-
-    # Opções de operadores
-    OPERADORES = ["<=", ">=", "<", ">", "="]
-    # Opções base de variáveis (serão atualizadas dinamicamente)
-    VARIAVEIS_BASE = ["Resíduo Pad.", "Resíduo Stud.", "Cook"]
-
-    header_secao_13 = gr.HTML(criar_header_secao(13, "Analisar Outliers"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_13:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_13:
-            gr.HTML('<div class="outlier-subheader">Métricas de Outliers</div>')
-            gr.HTML('<div class="outlier-dica">Métricas calculadas com base no modelo ajustado (resíduos com transformações aplicadas)</div>')
-
-            tabela_metricas = gr.Dataframe(
-                label="Métricas para identificação de outliers",
-                interactive=False,
-                max_height=300
-            )
-            with gr.Row():
-                btn_download_metricas = gr.Button("Baixar Métricas (CSV)", variant="secondary", size="sm")
-                download_metricas_file = gr.File(label="", visible=False)
-
-    # ========================================
-    # SEÇÃO 14: EXCLUSÃO DE OUTLIERS (ativada por Ajustar Modelo)
-    # ========================================
-    header_secao_14 = gr.HTML(criar_header_secao(14, "Exclusão ou Reinclusão de Outliers"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_14:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_14:
-            html_outliers_sec14 = gr.HTML(value="")
-            gr.HTML('<div class="outlier-subheader">Filtrar Outliers</div>')
-            gr.HTML('<div class="outlier-dica">Outliers = linhas que satisfazem QUALQUER filtro (lógica OR / União)</div>')
-
-            # Filtros dinâmicos (máximo 4 filtros)
-            filtro_rows = []
-            filtro_vars = []
-            filtro_ops = []
-            filtro_vals = []
-
-            for i in range(4):
-                visible = i < 2  # Filtros 1 e 2 visíveis por padrão
-                # Só define valores padrão para os filtros visíveis (0 e 1)
-                # Filtros ocultos (2 e 3) começam com None para não serem aplicados
-                if i == 0:
-                    valor_padrao = -2.0
-                    operador_padrao = "<="
-                    var_padrao = "Resíduo Pad."
-                elif i == 1:
-                    valor_padrao = 2.0
-                    operador_padrao = ">="
-                    var_padrao = "Resíduo Pad."
-                else:
-                    valor_padrao = None
-                    operador_padrao = None
-                    var_padrao = None
-
-                with gr.Row(visible=visible, elem_classes="filtro-row") as row:
-                    var_dropdown = gr.Dropdown(
-                        label=f"Variável {i+1}",
-                        choices=VARIAVEIS_BASE,
-                        value=var_padrao,
-                        scale=2
-                    )
-                    op_dropdown = gr.Dropdown(
-                        label="Operador",
-                        choices=OPERADORES,
-                        value=operador_padrao,
-                        scale=1
-                    )
-                    val_input = gr.Number(
-                        label="Valor",
-                        value=valor_padrao,
-                        scale=1
-                    )
-
-                filtro_rows.append(row)
-                filtro_vars.append(var_dropdown)
-                filtro_ops.append(op_dropdown)
-                filtro_vals.append(val_input)
-
-            with gr.Row(elem_classes="btn-filtro-acao-row"):
-                btn_adicionar_filtro = gr.Button("+", variant="secondary", scale=0, min_width=50, elem_classes="btn-filtro-acao btn-adicionar-filtro")
-                btn_remover_ultimo = gr.Button("−", variant="secondary", scale=0, min_width=50, elem_classes="btn-filtro-acao btn-remover-filtro")
-                btn_resetar_filtros = gr.Button("↺", variant="secondary", scale=0, min_width=50, elem_classes="btn-filtro-acao btn-voltar-padrao")
-
-            with gr.Row():
-                btn_aplicar_filtro = gr.Button("Aplicar Filtros", variant="primary", scale=1)
-
-            gr.HTML('<div class="outlier-divider"><span class="arrow">▼</span></div>')
-            gr.HTML('<div class="outlier-subheader">Confirmar Filtros Selecionados ou Ajustar Manualmente</div>')
-            gr.HTML('<div class="outlier-dica">Edite os índices manualmente ou confirme os resultados dos filtros acima</div>')
-
-            with gr.Row():
-                outliers_texto = gr.Textbox(
-                    label="Índices a Excluir",
-                    placeholder="Ex: 5, 12, 23",
-                    scale=3
-                )
-                reincluir_texto = gr.Textbox(
-                    label="Índices a Reincluir",
-                    placeholder="Ex: 5, 12",
-                    scale=3
-                )
-
-            with gr.Row():
-                txt_resumo_outliers = gr.Textbox(
-                    label="Resumo",
-                    value="Excluídos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0",
-                    interactive=False,
-                    elem_classes="resumo-outliers"
-                )
-
-            with gr.Row():
-                btn_reiniciar_iteracao = gr.Button(
-                    "Atualizar Modelo (Excluir/Reincluir Outliers)",
-                    variant="primary",
-                    scale=2,
-                    elem_classes="btn-reiniciar-iteracao"
-                )
-                btn_download_base = gr.Button("Baixar Base Tratada (CSV)", variant="secondary", scale=1)
-                download_base_file = gr.File(label="", visible=False)
-
-    # ========================================
-    # SEÇÃO 15: AVALIAÇÃO DE IMÓVEL (ativada por Ajustar Modelo)
-    # ========================================
-    N_COLS_AVAL = 4
-    N_ROWS_AVAL = MAX_VARS_X // N_COLS_AVAL  # 5
-
-    header_secao_15 = gr.HTML(criar_header_secao(15, "Avaliação de Imóvel"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_15:
-        with gr.Group(elem_classes="section-content"):
-            # Grid de inputs (5 rows × 4 cols = 20 inputs pré-criados) — visual de cards
-            aval_rows = []
-            aval_inputs = []
-            with gr.Column(elem_classes="aval-all-cards"):
-                for i in range(N_ROWS_AVAL):
-                    with gr.Row(visible=False, elem_classes="aval-cards-row") as aval_row:
-                        for j in range(N_COLS_AVAL):
-                            inp = gr.Number(label="", visible=False, interactive=True, elem_classes="aval-card")
-                            aval_inputs.append(inp)
-                    aval_rows.append(aval_row)
-
-            with gr.Row():
-                btn_calcular_avaliacao = gr.Button("Calcular Avaliação", variant="primary", scale=2)
-                btn_limpar_avaliacoes = gr.Button("Limpar Avaliações", variant="secondary", scale=1)
-            with gr.Row():
-                dropdown_base_avaliacao = gr.Dropdown(
-                    label="Base p/ comparação",
-                    choices=[],
-                    value=None,
-                    interactive=True,
-                    scale=1,
-                )
-
-            resultado_avaliacao_html = gr.HTML("")
-            excluir_aval_trigger = gr.Textbox(
-                label="", elem_id="excluir-aval-elab", container=False,
-                elem_classes="trigger-hidden"
-            )
-
-            with gr.Row():
-                btn_exportar_avaliacoes = gr.Button("Salvar Avaliações em Excel", variant="secondary")
-                download_avaliacoes_file = gr.File(label="", visible=False)
-
-    # ========================================
-    # SEÇÃO 16: EXPORTAR MODELO (ativada por Ajustar Modelo)
-    # ========================================
-    header_secao_16 = gr.HTML(criar_header_secao(16, "Exportar Modelo"), visible=True)
-    with gr.Accordion(
-        label="▼ Mostrar / Ocultar",
-        open=True,
-        visible=False,
-        elem_classes="section-accordion"
-    ) as accordion_secao_16:
-        with gr.Group(elem_classes="section-content") as conteudo_secao_16:
-            with gr.Row():
-                nome_arquivo = gr.Textbox(
-                    label="Nome do arquivo",
-                    placeholder="modelo_01",
-                    scale=2
-                )
-                dropdown_elaborador = gr.Dropdown(
-                    label="Elaborador",
-                    choices=_avaliadores_nomes,
-                    value=None,
-                    scale=2
-                )
-                btn_exportar = gr.Button("Exportar .dai", variant="primary", scale=1)
-
-            status_exportar = gr.Textbox(
-                label="Status da exportação",
-                interactive=False
-            )
-
-            download_modelo_file = gr.File(
-                label="",
-                visible=False
-            )
-
-    # ========================================
-    # EVENTOS
-    # ========================================
-
-    # --- Output lists compartilhadas ---
-
-    # CONTRACT: 196 itens — usada por upload.upload e btn_confirmar_aba.click
-    # Se alterar, atualizar: carregamento.py (5 funções retornam 196 itens)
-    _outputs_carregar = [
-        estado_df,
-        status,
-        dropdown_aba,
-        dropdown_y,
-        tabela_dados,
-        tabela_estatisticas,
-        checkboxes_x,
-        mapa_html,
-        estado_df_filtrado,
-        estado_outliers_anteriores,
-        estado_iteracao,
-        accordion_outliers_anteriores,
-        html_outliers_anteriores,
-        estado_arquivo_temp,
-        # Seções 2 e 3
-        header_secao_2,
-        accordion_secao_2,
-        dropdown_mapa_var,
-        header_secao_3,
-        accordion_secao_3,
-        # Reset seções 4-16 (states)
-        estado_modelo, estado_metricas, estado_resultados_busca, estado_avaliacoes,
-        # Headers, accordions e conteúdo das seções 4-16
-        header_secao_4, accordion_secao_4, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais,
-        html_aviso_multicolinearidade,
-        header_secao_5, accordion_secao_5,
-        header_secao_6, accordion_secao_6, html_micronumerosidade,
-        header_secao_7, accordion_secao_7, plot_dispersao,
-        header_secao_8, accordion_secao_8, slider_grau_coef, slider_grau_f, busca_html,
-        header_secao_9, accordion_secao_9, transformacao_y,
-        btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
-    ] + [transf_y_row, transf_y_col, transf_y_label] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [
-        header_secao_10, accordion_secao_10, dropdown_tipo_grafico_dispersao, plot_dispersao_transf,
-        header_secao_11, accordion_secao_11, diagnosticos_html, tabela_coef, tabela_obs_calc,
-        header_secao_12, accordion_secao_12, plot_obs_calc, plot_residuos, plot_hist, plot_cook, plot_corr,
-        header_secao_13, accordion_secao_13, tabela_metricas,
-        header_secao_14, accordion_secao_14, html_outliers_sec14, outliers_texto, reincluir_texto, txt_resumo_outliers,
-        # Seção 15: Avaliação de Imóvel
-        header_secao_15, accordion_secao_15,
-    ] + aval_rows + aval_inputs + [
-        resultado_avaliacao_html, dropdown_base_avaliacao, excluir_aval_trigger, download_avaliacoes_file,
-        # Seção 16: Exportar Modelo
-        header_secao_16, accordion_secao_16, nome_arquivo, status_exportar,
-        # Controles de visibilidade da seção 1 (pós-carregamento)
-        row_upload, row_selecao_aba, row_pos_carga, html_nome_arquivo_carregado,
-        # Flag para evitar que dropdown_y.change() sobrescreva valores durante carregamento
-        estado_flag_carregamento,
-    ] + filtro_vars + [  # 4 dropdowns de variável dos filtros (choices atualizados no fluxo .dai)
-        # Painel de coordenadas (Seção 1, Estado D) — itens 184-192
-        row_coords_panel,         # 184
-        html_aviso_coords,        # 185
-        dropdown_col_lat_manual,  # 186
-        dropdown_col_lon_manual,  # 187
-        dropdown_cdlog_geo,       # 188
-        dropdown_num_geo,         # 189
-        row_escolha_opcao,        # 190
-        row_opcao_mapear,         # 191
-        row_opcao_geocodificar,   # 192
-    ]
-
-    # CONTRACT: 33 itens — usada por btn_ajustar.click e btn_reiniciar_iteracao.then
-    # Se alterar, atualizar: modelo.py (ajustar_modelo_callback retorna 33 itens)
-    _outputs_ajustar = [
-        estado_modelo,
-        diagnosticos_html,
-        tabela_coef,
-        tabela_obs_calc,
-        plot_dispersao_transf,
-        dropdown_tipo_grafico_dispersao,
-        plot_obs_calc,
-        plot_residuos,
-        plot_hist,
-        plot_cook,
-        plot_corr,
-        tabela_metricas,
-        estado_metricas,
-        txt_resumo_outliers,
-        estado_avaliacoes,
-        # Seções 10-16
-        header_secao_10, accordion_secao_10,
-        header_secao_11, accordion_secao_11,
-        header_secao_12, accordion_secao_12,
-        header_secao_13, accordion_secao_13,
-        header_secao_14, accordion_secao_14,
-        header_secao_15, accordion_secao_15,
-        header_secao_16, accordion_secao_16,
-    ] + filtro_vars
-
-    # CONTRACT: 27 itens — usada por .then() após ajustar/reiniciar para popular campos de avaliação
-    _outputs_popular_avaliacao = aval_rows + aval_inputs + [resultado_avaliacao_html, dropdown_base_avaliacao]
-
-    # --- Inputs compartilhados para ajustar modelo ---
-    _inputs_ajustar = [
-        estado_df_filtrado, estado_df, dropdown_y, checkboxes_x,
-        transformacao_y, estado_outliers_anteriores, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais
-    ] + transf_x_dropdowns
-
-    # Upload de arquivo
-    upload.upload(
-        ao_carregar_arquivo,
-        inputs=[upload],
-        outputs=_outputs_carregar
-    ).then(
-        popular_campos_avaliacao_callback,
-        inputs=[estado_modelo, tabela_estatisticas],
-        outputs=_outputs_popular_avaliacao
-    ).then(
-        popular_dicotomicas_callback,
-        inputs=[estado_modelo, checkboxes_x, estado_df],
-        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
-    )
-
-    # Confirmação de aba (para Excel multi-aba)
-    btn_confirmar_aba.click(
-        confirmar_aba_callback,
-        inputs=[estado_arquivo_temp, dropdown_aba],
-        outputs=_outputs_carregar
-    ).then(
-        popular_campos_avaliacao_callback,
-        inputs=[estado_modelo, tabela_estatisticas],
-        outputs=_outputs_popular_avaliacao
-    ).then(
-        popular_dicotomicas_callback,
-        inputs=[estado_modelo, checkboxes_x, estado_df],
-        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
-    )
-
-    # Reiniciar aplicação (reload da página)
-    btn_reiniciar_app.click(
-        fn=None,
-        inputs=None,
-        outputs=None,
-        js="() => { window.location.reload(); }"
-    )
-
-    # ---- Painel de coordenadas (Seção 1, Estado D) ----
-
-    # Tela de escolha → entrar no painel Mapear
-    btn_escolher_mapear.click(
-        fn=lambda: (gr.update(visible=False), gr.update(visible=True)),
-        outputs=[row_escolha_opcao, row_opcao_mapear],
-    )
-
-    # Tela de escolha → entrar no painel Geocodificar
-    btn_escolher_geocodificar.click(
-        fn=lambda: (gr.update(visible=False), gr.update(visible=True)),
-        outputs=[row_escolha_opcao, row_opcao_geocodificar],
-    )
-
-    # Voltar do painel Mapear (limpa erro, reseta confirmação, volta à escolha)
-    btn_voltar_mapear.click(
-        fn=lambda: (gr.update(visible=False), gr.update(visible=True), gr.update(value=""), gr.update(visible=False)),
-        outputs=[row_opcao_mapear, row_escolha_opcao, html_erro_mapeamento, row_confirmacao_prosseguir],
-    )
-
-    # Voltar do painel Geocodificar (reset completo do estado de geocodificação — 68 itens)
-    N = MAX_FALHAS_GEO
-    btn_voltar_geocodificar.click(
-        fn=lambda: (
-            None, None, "",
-            *[gr.update(visible=False)] * N,
-            *[gr.update(value="")] * N,
-            *[gr.update(value=None)] * N,
-            gr.update(visible=False), gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False), gr.update(visible=True),
-        ),
-        outputs=(
-            [estado_geo_temp, estado_df_falhas, html_geo_status]
-            + falha_rows + falha_htmls + falha_inputs
-            + [btn_aplicar_correcoes_geo, btn_usar_coords_geo,
-               row_confirmacao_prosseguir,
-               row_opcao_geocodificar, row_escolha_opcao]
-        ),
-    )
-
-    # Opção 1: confirmar mapeamento manual de colunas
-    btn_confirmar_mapeamento.click(
-        fn=confirmar_mapeamento_callback,
-        inputs=[estado_df, dropdown_col_lat_manual, dropdown_col_lon_manual],
-        outputs=[
-            html_erro_mapeamento,
-            estado_df, estado_df_filtrado, mapa_html,
-            row_coords_panel, header_secao_2, accordion_secao_2,
-            header_secao_3, accordion_secao_3, status,
-        ]
-    )
-
-    # Opção 3: geocodificar por eixos (CONTRACT: 67 itens)
-    _outputs_geo = (
-        [estado_geo_temp, estado_df_falhas, html_geo_status]
-        + falha_rows + falha_htmls + falha_inputs
-        + [btn_aplicar_correcoes_geo, btn_usar_coords_geo]
-    )
-
-    btn_geocodificar.click(
-        fn=geocodificar_callback,
-        inputs=[estado_df, dropdown_cdlog_geo, dropdown_num_geo, checkbox_auto_200],
-        outputs=_outputs_geo,
-        show_progress="full",
-    )
-
-    btn_aplicar_correcoes_geo.click(
-        fn=aplicar_correcoes_geo_callback,
-        inputs=(
-            [estado_geo_temp, estado_df_falhas]
-            + falha_inputs
-            + [dropdown_cdlog_geo, dropdown_num_geo, checkbox_auto_200]
-        ),
-        outputs=_outputs_geo,
-        show_progress="full",
-    )
-
-    btn_usar_coords_geo.click(
-        fn=confirmar_geocodificacao_callback,
-        inputs=[estado_geo_temp],
-        outputs=[
-            estado_df, estado_df_filtrado, mapa_html,
-            row_coords_panel, header_secao_2, accordion_secao_2,
-            header_secao_3, accordion_secao_3, status,
-        ]
-    )
-
-    # Prosseguir sem coordenadas completas (dois cliques: exibe aviso → confirma)
-    btn_prosseguir_sem_coords.click(
-        fn=lambda: gr.update(visible=True),
-        outputs=[row_confirmacao_prosseguir]
-    )
-
-    btn_confirmar_prosseguir.click(
-        fn=lambda geo_df, orig_df: confirmar_sem_coords_callback(geo_df if geo_df is not None else orig_df),
-        inputs=[estado_geo_temp, estado_df],
-        outputs=[
-            estado_df, estado_df_filtrado, mapa_html,
-            row_coords_panel, header_secao_2, accordion_secao_2,
-            header_secao_3, accordion_secao_3, status,
-        ]
-    )
-
-    # Mudança de y (NÃO mostra seção 4, NÃO atualiza estatísticas - só atualiza checkboxes)
-    dropdown_y.change(
-        ao_mudar_y_sem_estatisticas,
-        inputs=[estado_df, dropdown_y, estado_flag_carregamento],
-        outputs=[checkboxes_x, header_secao_4, accordion_secao_4, estado_flag_carregamento]
-    ).then(
-        popular_dicotomicas_callback,
-        inputs=[estado_modelo, checkboxes_x, estado_df],
-        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
-    )
-
-    # Selecionar/Desselecionar todos via checkbox
-    def toggle_selecionar_todos(selecionar, df, coluna_y):
-        """Marca ou desmarca todas as variáveis independentes."""
-        if selecionar:
-            # Marcar todos
-            colunas_x = [col for col in obter_colunas_numericas(df) if col != coluna_y] if df is not None and coluna_y else []
-            return gr.update(value=colunas_x)
-        else:
-            # Desmarcar todos
-            return gr.update(value=[])
-
-    checkbox_selecionar_todos.change(
-        toggle_selecionar_todos,
-        inputs=[checkbox_selecionar_todos, estado_df, dropdown_y],
-        outputs=[checkboxes_x]
-    )
-
-    # Clique na tabela -> atualiza mapa
-    tabela_dados.select(
-        ao_clicar_tabela,
-        inputs=[estado_df, dropdown_mapa_var],
-        outputs=[mapa_html]
-    )
-
-    # Mudança de variável no dropdown do mapa -> atualiza mapa
-    dropdown_mapa_var.input(
-        atualizar_mapa_callback,
-        inputs=[estado_df_filtrado, estado_df, dropdown_mapa_var],
-        outputs=[mapa_html]
-    )
-
-    # Seleção de X -> atualiza campos de transformação (preview)
-    checkboxes_x.change(
-        _atualizar_campos_transformacoes_com_flag,
-        inputs=[estado_df, checkboxes_x, estado_flag_carregamento, dropdown_y],
-        outputs=[transf_y_row, transf_y_col, transf_y_label] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [estado_flag_carregamento, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
-    )
-
-    # Mudança de qualquer checkbox de tipo -> atualiza interactive dos dropdowns de transformação
-    _inputs_interativo = [checkboxes_x, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais, estado_df]
-    checkboxes_dicotomicas.change(
-        atualizar_interativo_dicotomicas,
-        inputs=_inputs_interativo,
-        outputs=transf_x_dropdowns
-    )
-    checkboxes_codigo_alocado.change(
-        atualizar_interativo_dicotomicas,
-        inputs=_inputs_interativo,
-        outputs=transf_x_dropdowns
-    )
-    checkboxes_percentuais.change(
-        atualizar_interativo_dicotomicas,
-        inputs=_inputs_interativo,
-        outputs=transf_x_dropdowns
-    )
-
-    # Aplicar seleção de Y -> atualiza X disponíveis e MOSTRA seção 4 (NÃO atualiza estatísticas)
-    btn_aplicar_y.click(
-        lambda df, y: ao_mudar_y_sem_estatisticas(df, y, mostrar_secao_x=True),
-        inputs=[estado_df, dropdown_y],
-        outputs=[checkboxes_x, header_secao_4, accordion_secao_4, estado_flag_carregamento]
-    ).then(
-        popular_dicotomicas_callback,
-        inputs=[estado_modelo, checkboxes_x, estado_df],
-        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
-    )
-
-    # Aplicar seleção de variáveis X -> atualiza estatísticas, busca transformações, dispersão e micronumerosidade
-    btn_aplicar_selecao_x.click(
-        aplicar_selecao_callback,
-        inputs=[estado_df, dropdown_y, checkboxes_x, estado_outliers_anteriores, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais],
-        outputs=[
-            estado_df_filtrado,
-            tabela_estatisticas,
-            html_micronumerosidade,
-            plot_dispersao,
-            slider_grau_coef, slider_grau_f,
-            busca_html,
-            estado_resultados_busca,
-            btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
-            # Seções 5-9
-            header_secao_5, accordion_secao_5,
-            header_secao_6, accordion_secao_6,
-            header_secao_7, accordion_secao_7,
-            header_secao_8, accordion_secao_8,
-            header_secao_9, accordion_secao_9,
-        ] + [transf_y_row, transf_y_col, transf_y_label] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [html_aviso_multicolinearidade]
-    )
-
-    # Re-executar busca ao alterar grau (modo manual, sem fallback)
-    def _rebuscar_transformacoes(df, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, grau_coef, grau_f):
-        if df is None or coluna_y is None or not colunas_x:
-            return (gr.update(), gr.update(), *[gr.update()] * 5)
-        html, resultados, _, *btn_updates = buscar_transformacoes_callback(
-            df, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, int(grau_coef), int(grau_f)
-        )
-        return (html, resultados, *btn_updates)
-
-    _inputs_rebuscar = [estado_df_filtrado, dropdown_y, checkboxes_x, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais, slider_grau_coef, slider_grau_f]
-    _outputs_rebuscar = [busca_html, estado_resultados_busca,
-                         btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5]
-
-    slider_grau_coef.change(
-        _rebuscar_transformacoes,
-        inputs=_inputs_rebuscar,
-        outputs=_outputs_rebuscar
-    )
-
-    slider_grau_f.change(
-        _rebuscar_transformacoes,
-        inputs=_inputs_rebuscar,
-        outputs=_outputs_rebuscar
-    )
-
-    # Aplicar filtros de outliers
-    btn_aplicar_filtro.click(
-        aplicar_filtros_callback,
-        inputs=[estado_metricas, estado_n_filtros] + filtro_vars + filtro_ops + filtro_vals,
-        outputs=[outliers_texto]
-    )
-
-    # Adicionar filtro
-    btn_adicionar_filtro.click(
-        adicionar_filtro_callback,
-        inputs=[estado_n_filtros],
-        outputs=[estado_n_filtros] + filtro_rows
-    )
-
-    # Remover último filtro
-    btn_remover_ultimo.click(
-        remover_ultimo_filtro_callback,
-        inputs=[estado_n_filtros],
-        outputs=[estado_n_filtros] + filtro_rows
-    )
-
-    # Resetar filtros ao padrão
-    btn_resetar_filtros.click(
-        limpar_filtros_callback,
-        inputs=[],
-        outputs=[estado_n_filtros] + filtro_rows + filtro_vars + filtro_ops + filtro_vals + [outliers_texto]
-    )
-
-    # Atualizar resumo de outliers quando usuário edita os campos
-    outliers_texto.change(
-        atualizar_resumo_outliers,
-        inputs=[estado_outliers_anteriores, outliers_texto, reincluir_texto],
-        outputs=[txt_resumo_outliers]
-    )
-
-    reincluir_texto.change(
-        atualizar_resumo_outliers,
-        inputs=[estado_outliers_anteriores, outliers_texto, reincluir_texto],
-        outputs=[txt_resumo_outliers]
-    )
-
-    # Aplicar filtro também atualiza o resumo
-    btn_aplicar_filtro.click(
-        atualizar_resumo_outliers,
-        inputs=[estado_outliers_anteriores, outliers_texto, reincluir_texto],
-        outputs=[txt_resumo_outliers]
-    )
-
-    # Download da base tratada (CSV)
-    def download_base_callback(df_filtrado, df_original):
-        """Callback para download da base tratada."""
-        # Usa df_filtrado se disponível, senão usa df_original
-        df_para_exportar = df_filtrado if df_filtrado is not None else df_original
-
-        if df_para_exportar is None:
-            return gr.update(value=None, visible=False)
-
-        try:
-            if hasattr(df_para_exportar, 'empty') and df_para_exportar.empty:
-                return gr.update(value=None, visible=False)
-
-            caminho = exportar_base_csv(df_para_exportar)
-            if caminho:
-                return gr.update(value=caminho, visible=True)
-            else:
-                return gr.update(value=None, visible=False)
-        except Exception as e:
-            print(f"Erro ao exportar CSV: {e}")
-            return gr.update(value=None, visible=False)
-
-    btn_download_base.click(
-        download_base_callback,
-        inputs=[estado_df_filtrado, estado_df],
-        outputs=[download_base_file]
-    )
-
-    # Botões "Adotar Sugestão"
-    btn_adotar_1.click(
-        lambda res, cols_x: adotar_sugestao(0, res, cols_x),
-        inputs=[estado_resultados_busca, checkboxes_x],
-        outputs=[transformacao_y] + transf_x_dropdowns
-    )
-    btn_adotar_2.click(
-        lambda res, cols_x: adotar_sugestao(1, res, cols_x),
-        inputs=[estado_resultados_busca, checkboxes_x],
-        outputs=[transformacao_y] + transf_x_dropdowns
-    )
-    btn_adotar_3.click(
-        lambda res, cols_x: adotar_sugestao(2, res, cols_x),
-        inputs=[estado_resultados_busca, checkboxes_x],
-        outputs=[transformacao_y] + transf_x_dropdowns
-    )
-    btn_adotar_4.click(
-        lambda res, cols_x: adotar_sugestao(3, res, cols_x),
-        inputs=[estado_resultados_busca, checkboxes_x],
-        outputs=[transformacao_y] + transf_x_dropdowns
-    )
-    btn_adotar_5.click(
-        lambda res, cols_x: adotar_sugestao(4, res, cols_x),
-        inputs=[estado_resultados_busca, checkboxes_x],
-        outputs=[transformacao_y] + transf_x_dropdowns
-    )
-
-    # Ajustar modelo (usa dados filtrados se disponíveis) e calcula métricas de outliers
-    dropdown_tipo_grafico_dispersao.change(
-        fn=ao_mudar_tipo_grafico,
-        inputs=[dropdown_tipo_grafico_dispersao, estado_modelo],
-        outputs=[plot_dispersao_transf]
-    )
-
-    btn_ajustar.click(
-        lambda df_filt, df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals: ajustar_modelo_callback(
-            df_filt if df_filt is not None else df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals
-        ),
-        inputs=_inputs_ajustar,
-        outputs=_outputs_ajustar
-    ).then(
-        popular_campos_avaliacao_callback,
-        inputs=[estado_modelo, tabela_estatisticas],
-        outputs=_outputs_popular_avaliacao
-    )
-
-    # Reiniciar iteração (combina outliers e recomeça) e depois ajusta o modelo
-    btn_reiniciar_iteracao.click(
-        reiniciar_iteracao_callback,
-        inputs=[
-            estado_df, estado_outliers_anteriores, outliers_texto, reincluir_texto,
-            estado_iteracao, dropdown_y, checkboxes_x, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais, slider_grau_coef, slider_grau_f
-        ],
-        outputs=[
-            estado_outliers_anteriores,
-            estado_iteracao,
-            estado_df_filtrado,
-            tabela_dados,
-            tabela_estatisticas,
-            header_secao_5,
-            html_outliers_anteriores,
-            html_outliers_sec14,
-            accordion_outliers_anteriores,
-            outliers_texto,
-            reincluir_texto,
-            tabela_metricas,
-            estado_metricas,
-            header_secao_13,
-            txt_resumo_outliers,
-            mapa_html,
-            # Novos outputs para seções 2, 6, 7, 8
-            header_secao_2,
-            html_micronumerosidade,
-            header_secao_6,
-            plot_dispersao,
-            header_secao_7,
-            busca_html,
-            estado_resultados_busca,
-            header_secao_8,
-            btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
-            slider_grau_coef,
-            slider_grau_f,
-        ]
-    ).then(
-        # Após reiniciar, ajusta modelo automaticamente para calcular métricas de outliers
-        lambda df_filt, df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals: ajustar_modelo_callback(
-            df_filt if df_filt is not None else df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals
-        ),
-        inputs=_inputs_ajustar,
-        outputs=_outputs_ajustar
-    ).then(
-        popular_campos_avaliacao_callback,
-        inputs=[estado_modelo, tabela_estatisticas],
-        outputs=_outputs_popular_avaliacao
-    ).then(
-        fn=None,
-        inputs=None,
-        outputs=None,
-        js="""() => {
-            if ('parentIFrame' in window) {
-                window.parentIFrame.scrollTo({top: 0, behavior: 'smooth'});
-            } else {
-                window.scrollTo({top: 0, behavior: 'smooth'});
-            }
-        }"""
-    )
-
-    # Limpar histórico de outliers
-    btn_limpar_historico.click(
-        limpar_historico_callback,
-        inputs=[estado_df],
-        outputs=[
-            estado_outliers_anteriores,
-            estado_iteracao,
-            estado_df_filtrado,
-            tabela_dados,
-            tabela_estatisticas,
-            mapa_html,
-            html_outliers_anteriores,
-            accordion_outliers_anteriores,
-            header_secao_2,
-            # Reset seções 4-16 (states)
-            estado_modelo, estado_metricas, estado_resultados_busca, estado_avaliacoes,
-            # Headers, accordions e conteúdo das seções 4-16
-            header_secao_4, accordion_secao_4, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais,
-            html_aviso_multicolinearidade,
-            header_secao_5, accordion_secao_5,
-            header_secao_6, accordion_secao_6, html_micronumerosidade,
-            header_secao_7, accordion_secao_7, plot_dispersao,
-            header_secao_8, accordion_secao_8, slider_grau_coef, slider_grau_f, busca_html,
-            header_secao_9, accordion_secao_9, transformacao_y,
-            btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
-        ] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [
-            header_secao_10, accordion_secao_10, dropdown_tipo_grafico_dispersao, plot_dispersao_transf,
-            header_secao_11, accordion_secao_11, diagnosticos_html, tabela_coef, tabela_obs_calc,
-            header_secao_12, accordion_secao_12, plot_obs_calc, plot_residuos, plot_hist, plot_cook, plot_corr,
-            header_secao_13, accordion_secao_13, tabela_metricas,
-            header_secao_14, accordion_secao_14, html_outliers_sec14, outliers_texto, reincluir_texto, txt_resumo_outliers,
-            # Seção 15: Avaliação de Imóvel
-            header_secao_15, accordion_secao_15,
-        ] + aval_rows + aval_inputs + [
-            resultado_avaliacao_html, dropdown_base_avaliacao, excluir_aval_trigger, download_avaliacoes_file,
-            # Seção 16: Exportar Modelo
-            header_secao_16, accordion_secao_16, nome_arquivo, status_exportar,
-        ] + filtro_vars
-    )
-
-    # Exportar (usa dados filtrados se disponíveis)
-    btn_exportar.click(
-        lambda res_modelo, df_filt, df_orig, stats, nome, elab_nome, outliers: exportar_modelo_callback(
-            res_modelo, df_filt if df_filt is not None else df_orig, df_orig, stats, nome,
-            _avaliadores_dict.get(elab_nome) if elab_nome else None,
-            outliers or []
-        ),
-        inputs=[estado_modelo, estado_df_filtrado, estado_df, tabela_estatisticas, nome_arquivo, dropdown_elaborador, estado_outliers_anteriores],
-        outputs=[status_exportar, download_modelo_file]
-    )
-
-    # Avaliação de imóvel (seção 15)
-    btn_calcular_avaliacao.click(
-        avaliar_imovel_callback,
-        inputs=[estado_modelo, tabela_estatisticas, estado_avaliacoes, dropdown_base_avaliacao] + aval_inputs,
-        outputs=[resultado_avaliacao_html, estado_avaliacoes, dropdown_base_avaliacao]
-    )
-
-    btn_limpar_avaliacoes.click(
-        limpar_avaliacoes_callback,
-        inputs=[],
-        outputs=[resultado_avaliacao_html, estado_avaliacoes, dropdown_base_avaliacao]
-    )
-
-    excluir_aval_trigger.change(
-        excluir_avaliacao_callback,
-        inputs=[excluir_aval_trigger, estado_avaliacoes, dropdown_base_avaliacao],
-        outputs=[resultado_avaliacao_html, estado_avaliacoes, dropdown_base_avaliacao, excluir_aval_trigger]
-    )
-
-    dropdown_base_avaliacao.change(
-        atualizar_base_avaliacao_callback,
-        inputs=[estado_avaliacoes, dropdown_base_avaliacao],
-        outputs=[resultado_avaliacao_html]
-    )
-
-    btn_exportar_avaliacoes.click(
-        exportar_avaliacoes_excel_callback,
-        inputs=[estado_avaliacoes],
-        outputs=[download_avaliacoes_file]
-    )
-
-    # Downloads de tabelas
-    btn_download_estatisticas.click(
-        lambda df: download_tabela_callback(df, "estatisticas"),
-        inputs=[tabela_estatisticas],
-        outputs=[download_estatisticas_file]
-    )
-
-    btn_download_dados.click(
-        lambda df: download_tabela_callback(df, "dados"),
-        inputs=[tabela_dados],
-        outputs=[download_dados_file]
-    )
-
-    btn_download_coef.click(
-        lambda df: download_tabela_callback(df, "coeficientes"),
-        inputs=[tabela_coef],
-        outputs=[download_coef_file]
-    )
-
-    btn_download_obs_calc.click(
-        lambda df: download_tabela_callback(df, "obs_calc"),
-        inputs=[tabela_obs_calc],
-        outputs=[download_obs_calc_file]
-    )
-
-    btn_download_metricas.click(
-        lambda df: download_tabela_callback(df, "metricas"),
-        inputs=[tabela_metricas],
-        outputs=[download_metricas_file]
-    )
-
-
-
-# ============================================================
-# MAIN
-# ============================================================
-
-if __name__ == "__main__":
-    css = carregar_css()
-    with gr.Blocks(title="Elaboração de Modelos", css=css) as app:
-        gr.Markdown(TITULO)
-        criar_aba()
-    app.queue().launch()

backend/app/core/elaboracao/carregamento.py

@@ -1,639 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-carregamento.py - Carga de arquivos, reset de estado e inicialização.
-
-Callbacks que lidam com upload de CSV/Excel/.dai,
-seleção de aba Excel, reset de seções e limpar histórico.
-"""
-
-import gradio as gr
-import os
-from datetime import datetime, timezone, timedelta
-
-from .formatadores import arredondar_df, criar_header_secao, formatar_lista_variaveis_html
-from .modelo import (
-    aplicar_selecao_callback,
-    ajustar_modelo_callback,
-    MAX_VARS_X,
-)
-from .core import (
-    detectar_abas_excel,
-    carregar_arquivo,
-    carregar_dai,
-    obter_colunas_numericas,
-    identificar_coluna_y_padrao,
-    formatar_transformacao,
-)
-from .charts import criar_mapa
-from .geocodificacao import verificar_coords, auto_detectar_colunas_geo, padronizar_coords
-
-
-# ============================================================
-# RESET DE SEÇÕES
-# ============================================================
-
-def _valores_reset_secoes_4_a_16():
-    """Valores de reset para seções 4-16 (headers, accordions e conteúdo).
-
-    Headers são resetados para remover timestamps. Accordions são fechados.
-    Usado por carregar_dados_do_arquivo e limpar_historico_callback para limpar
-    todas as seções quando um novo arquivo é carregado ou o histórico é resetado.
-
-    CONTRACT: Retorna 156 itens.
-    Se alterar, atualizar: TODAS as funções neste arquivo que retornam 193 itens
-    (ao_carregar_arquivo, _resultado_selecao_aba, confirmar_aba_callback,
-    carregar_dados_de_dai, carregar_dados_do_arquivo) + limpar_historico_callback.
-    """
-    n_rows = (MAX_VARS_X + 7) // 8  # 3
-    return (
-        # States
-        None,   # estado_modelo
-        None,   # estado_metricas
-        [],     # estado_resultados_busca
-        [],     # estado_avaliacoes
-        # Section 4
-        gr.update(value=criar_header_secao(4, "Selecionar Variáveis Independentes")),  # header_secao_4
-        gr.update(visible=False),  # accordion_secao_4
-        gr.update(choices=[], value=[], visible=False),  # checkboxes_dicotomicas
-        gr.update(choices=[], value=[], visible=False),  # checkboxes_codigo_alocado
-        gr.update(choices=[], value=[], visible=False),  # checkboxes_percentuais
-        gr.update(value="", visible=False),              # html_aviso_multicolinearidade
-        # Section 5
-        gr.update(value=criar_header_secao(5, "Estatísticas das Variáveis Selecionadas")),  # header_secao_5
-        gr.update(visible=False),  # accordion_secao_5
-        # Section 6
-        gr.update(value=criar_header_secao(6, "Teste de Micronumerosidade (NBR 14.653-2)")),  # header_secao_6
-        gr.update(visible=False),  # accordion_secao_6
-        "",  # html_micronumerosidade
-        # Section 7
-        gr.update(value=criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes")),  # header_secao_7
-        gr.update(visible=False),  # accordion_secao_7
-        None,  # plot_dispersao
-        # Section 8
-        gr.update(value=criar_header_secao(8, "Transformações Sugeridas")),  # header_secao_8
-        gr.update(visible=False),  # accordion_secao_8
-        gr.update(value=3),  # slider_grau_coef
-        gr.update(value=3),  # slider_grau_f
-        "",  # busca_html
-        # Section 9
-        gr.update(value=criar_header_secao(9, "Aplicação das Transformações")),  # header_secao_9
-        gr.update(visible=False),  # accordion_secao_9
-        gr.update(value="(x)"),  # transformacao_y
-        *[gr.update(visible=False) for _ in range(5)],  # btn_adotar 1-5
-        gr.update(visible=False),                         # transf_y_row
-        gr.update(visible=False),                         # transf_y_col
-        gr.update(value="", visible=False),               # transf_y_label
-        # transf_x_rows, transf_x_columns, transf_x_labels, transf_x_dropdowns (63 itens)
-        *[gr.update(visible=False) for _ in range(n_rows)],
-        *[gr.update(visible=False) for _ in range(MAX_VARS_X)],
-        *[gr.update(value="", visible=False) for _ in range(MAX_VARS_X)],
-        *[gr.update(value="(x)", interactive=True, visible=False) for _ in range(MAX_VARS_X)],
-        # Section 10
-        gr.update(value=criar_header_secao(10, "Gráficos de Dispersão (Variáveis Transformadas)")),  # header_secao_10
-        gr.update(visible=False),  # accordion_secao_10
-        gr.update(value="Variáveis Independentes Transformadas X Variável Dependente Transformada", visible=False),  # dropdown_tipo_grafico_dispersao
-        None,  # plot_dispersao_transf
-        # Section 11
-        gr.update(value=criar_header_secao(11, "Diagnóstico de Modelo")),  # header_secao_11
-        gr.update(visible=False),  # accordion_secao_11
-        "",  # diagnosticos_html
-        None,  # tabela_coef
-        None,  # tabela_obs_calc
-        # Section 12
-        gr.update(value=criar_header_secao(12, "Gráficos de Diagnóstico do Modelo")),  # header_secao_12
-        gr.update(visible=False),  # accordion_secao_12
-        None, None, None, None, None,  # plots: obs_calc, residuos, hist, cook, corr
-        # Section 13
-        gr.update(value=criar_header_secao(13, "Analisar Outliers")),  # header_secao_13
-        gr.update(visible=False),  # accordion_secao_13
-        None,  # tabela_metricas
-        # Section 14 (exclusão)
-        gr.update(value=criar_header_secao(14, "Exclusão ou Reinclusão de Outliers")),  # header_secao_14
-        gr.update(visible=False),  # accordion_secao_14
-        "",  # html_outliers_sec14
-        "",  # outliers_texto
-        "",  # reincluir_texto
-        "Excluídos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0",  # txt_resumo_outliers
-        # Section 15 (Avaliação de Imóvel)
-        gr.update(value=criar_header_secao(15, "Avaliação de Imóvel")),  # header_secao_15
-        gr.update(visible=False),  # accordion_secao_15
-        *[gr.update(visible=False) for _ in range(MAX_VARS_X // 4)],  # aval_rows (5)
-        *[gr.update(visible=False, value=None, label="") for _ in range(MAX_VARS_X)],  # aval_inputs (20)
-        "",  # resultado_avaliacao_html
-        gr.update(choices=[], value=None),  # dropdown_base_avaliacao
-        "",  # excluir_aval_trigger
-        gr.update(value=None, visible=False),  # download_avaliacoes_file
-        # Section 16 (Exportar Modelo)
-        gr.update(value=criar_header_secao(16, "Exportar Modelo")),  # header_secao_16
-        gr.update(visible=False),  # accordion_secao_16
-        gr.update(value=""),  # nome_arquivo
-        gr.update(value=""),  # status_exportar
-    )
-
-
-# ============================================================
-# CALLBACKS DE CARREGAMENTO
-# ============================================================
-
-def ao_carregar_arquivo(arquivo):
-    """Callback quando arquivo é carregado. Detecta se há múltiplas abas no Excel.
-
-    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
-    Se alterar, atualizar: _outputs_carregar em app.py + TODAS as 5 funções neste arquivo.
-    """
-    caminho_arquivo = arquivo.name if hasattr(arquivo, 'name') else str(arquivo)
-    nome_exibicao = "Arquivo carregado: " + os.path.basename(caminho_arquivo)
-
-    # Se for arquivo .dai, carrega modelo completo
-    if caminho_arquivo.endswith('.dai'):
-        return carregar_dados_de_dai(caminho_arquivo)
-
-    # Detecta abas do Excel
-    abas, msg_abas, sucesso_abas = detectar_abas_excel(caminho_arquivo)
-
-    # Se há múltiplas abas, mostra seletor de aba (não carrega dados ainda)
-    if sucesso_abas and len(abas) > 1:
-        return _resultado_selecao_aba(caminho_arquivo, abas)
-
-    # Se não há múltiplas abas, carrega diretamente
-    return carregar_dados_do_arquivo(caminho_arquivo, None,
-                                     nome_arquivo_exibicao=nome_exibicao)
-
-
-def _resultado_selecao_aba(caminho_arquivo, abas):
-    """Retorna tupla para estado B: mostra seletor de aba, não carrega dados ainda.
-
-    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
-    """
-    return (
-        None,  # estado_df (sem dados ainda)
-        "Arquivo com múltiplas abas detectado. Selecione uma aba e confirme.",  # status
-        gr.update(choices=abas, value=abas[0]),  # dropdown_aba
-        gr.update(choices=[], value=None),  # dropdown_y
-        None,  # tabela_dados
-        None,  # tabela_estatisticas
-        gr.update(choices=[]),  # checkboxes_x
-        "<p>Carregue um arquivo para ver o mapa.</p>",  # mapa
-        None,  # estado_df_filtrado
-        [],    # estado_outliers_anteriores
-        1,     # estado_iteracao
-        gr.update(visible=False),  # accordion_outliers_anteriores
-        "",                        # html_outliers_anteriores
-        caminho_arquivo,  # estado_arquivo_temp (manter caminho para confirmar_aba)
-        # Seções 2 e 3 - ocultas
-        gr.update(visible=False),  # header_secao_2
-        gr.update(visible=False),  # accordion_secao_2
-        gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),  # dropdown_mapa_var
-        gr.update(visible=False),  # header_secao_3
-        gr.update(visible=False),  # accordion_secao_3
-        # Reset seções 4-16
-        *_valores_reset_secoes_4_a_16(),
-        # Controles de visibilidade da seção 1
-        gr.update(visible=False),   # row_upload (ocultar upload)
-        gr.update(visible=True),    # row_selecao_aba (mostrar seletor de aba)
-        gr.update(visible=False),   # row_pos_carga (ocultar restart)
-        gr.update(value=""),        # html_nome_arquivo_carregado
-        False,                      # estado_flag_carregamento
-        *[gr.update()] * 4,         # filtro_vars (no-op)
-        # Painel de coordenadas (no-op — dados ainda não carregados)
-        gr.update(visible=False), gr.update(value=""),
-        gr.update(choices=[]), gr.update(choices=[]),
-        gr.update(choices=[], value=None), gr.update(choices=[], value=None),
-        gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
-        gr.update(visible=False),  # row_opcao_mapear
-        gr.update(visible=False),  # row_opcao_geocodificar
-    )
-
-
-def confirmar_aba_callback(caminho_arquivo, nome_aba):
-    """Callback quando usuário confirma seleção de aba para Excel multi-aba.
-
-    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
-    """
-    if caminho_arquivo is None or nome_aba is None:
-        return (
-            None, "Erro: arquivo não encontrado. Recarregue a página.",
-            gr.update(choices=[], value=None),  # dropdown_aba
-            gr.update(choices=[], value=None),  # dropdown_y
-            None, None, gr.update(choices=[]),
-            "<p>Carregue um arquivo para ver o mapa.</p>",
-            None, [], 1, gr.update(visible=False),
-            "", None,
-            gr.update(visible=False), gr.update(visible=False),
-            gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),
-            gr.update(visible=False), gr.update(visible=False),
-            *_valores_reset_secoes_4_a_16(),
-            # Volta ao estado de upload em caso de erro
-            gr.update(visible=True),   # row_upload
-            gr.update(visible=False),  # row_selecao_aba
-            gr.update(visible=False),  # row_pos_carga
-            gr.update(value=""),       # html_nome_arquivo_carregado
-            False,                     # estado_flag_carregamento
-            *[gr.update()] * 4,        # filtro_vars (no-op)
-            # Painel de coordenadas (no-op — erro)
-            gr.update(visible=False), gr.update(value=""),
-            gr.update(choices=[]), gr.update(choices=[]),
-            gr.update(choices=[], value=None), gr.update(choices=[], value=None),
-            gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
-            gr.update(visible=False),  # row_opcao_mapear
-            gr.update(visible=False),  # row_opcao_geocodificar
-        )
-
-    nome_exibicao = "Arquivo carregado: "+os.path.basename(caminho_arquivo)
-    nome_exibicao_completo = f"{nome_exibicao} — Aba: {nome_aba}"
-    return carregar_dados_do_arquivo(caminho_arquivo, nome_aba,
-                                     nome_arquivo_exibicao=nome_exibicao_completo)
-
-
-def carregar_dados_de_dai(caminho_arquivo):
-    """Carrega arquivo .dai e popula toda a interface com o modelo reconstruído.
-
-    Executa o mesmo fluxo que o usuário faria manualmente:
-    1. Carrega dados (como carregar_dados_do_arquivo)
-    2. Aplica seleção de variáveis (como aplicar_selecao_callback)
-    3. Sobrescreve transformações com valores do .dai
-    4. Ajusta modelo (como ajustar_modelo_callback)
-
-    CONTRACT: Retorna 196 itens para _outputs_carregar (app.py:criar_aba).
-    Consome aplicar_selecao_callback por índice (r[0], r[1], ..., r[23:]).
-    Consome ajustar_modelo_callback por índice (m[0], ..., m[32]).
-    """
-    (
-        df,
-        coluna_y,
-        colunas_x,
-        transformacao_y,
-        transformacoes_x,
-        dicotomicas,
-        codigo_alocado,
-        percentuais,
-        msg,
-        sucesso,
-        elaborador,
-        _observacao_modelo,
-        outliers_excluidos,
-        _periodo_dados_mercado,
-        _config_avaliacao,
-    ) = carregar_dai(caminho_arquivo)
-
-    nome_exibicao = os.path.basename(caminho_arquivo)
-    html_nome = f"<h2 style='margin:0 0 12px 0; font-size:1.4em;'>{nome_exibicao}</h2>"
-    if elaborador:
-        nome_elab = elaborador.get("nome_completo", "")
-        cargo = elaborador.get("cargo", "")
-        conselho = elaborador.get("conselho", "")
-        num_conselho = elaborador.get("numero_conselho", "")
-        estado_conselho = elaborador.get("estado_conselho", "")
-        matricula = elaborador.get("matricula_sem_digito", "")
-        lotacao = elaborador.get("lotacao", "")
-        linha2 = f"{cargo} · {conselho}/{estado_conselho} {num_conselho}" if cargo else ""
-        linha3 = f"Matrícula: {matricula} · {lotacao}" if matricula else ""
-        if nome_elab:
-            info_variaveis = (
-                [f"{coluna_y}: {formatar_transformacao(transformacao_y, is_y=True)}"]
-                + [f"{col}: {formatar_transformacao(transformacoes_x.get(col, '(x)'))}"
-                   for col in colunas_x]
-            )
-            variaveis_lado_direito = formatar_lista_variaveis_html(info_variaveis)
-            html_nome += (
-                '<div style="display:flex; justify-content:space-between; align-items:flex-start; '
-                'gap:24px; background:#e9ecef; border-left:5px solid #6c757d; '
-                'border-radius:6px; padding:14px 18px; color:#495057; line-height:1.8; margin-top:8px;">'
-                '<div>'
-                f'<span style="display:block; font-size:1.15em; font-weight:600; color:#212529; margin-bottom:4px;">{nome_elab}</span>'
-                + (f'<span style="display:block; font-size:1em;">{linha2}</span>' if linha2 else '')
-                + (f'<span style="display:block; font-size:0.95em; color:#6c757d;">{linha3}</span>' if linha3 else '')
-                + '</div>'
-                + f'<div>{variaveis_lado_direito}</div>'
-                + '</div>'
-            )
-
-    if outliers_excluidos:
-        lista_str = ", ".join(map(str, sorted(outliers_excluidos)))
-        n = len(outliers_excluidos)
-        html_outliers_content = (
-            '<div style="display:flex; gap:16px; align-items:baseline; padding:10px 16px; '
-            'background:var(--background-fill-secondary,#f8f9fa); border-radius:8px; '
-            'border:1px solid var(--border-color-primary,#e2e8f0); flex-wrap:wrap;">'
-            f'<span style="font-weight:600; color:var(--body-text-color,#495057); white-space:nowrap;">'
-            f'{n} outlier(s) excluídos do modelo ajustado</span>'
-            f'<span style="color:var(--body-text-color-subdued,#6c757d); font-size:0.92em;">'
-            f'Índices: {lista_str}</span>'
-            '</div>'
-        )
-    else:
-        html_outliers_content = ""
-
-    if not sucesso:
-        return (
-            None, msg, gr.update(), gr.update(choices=[], value=None),
-            None, None, gr.update(choices=[]), "<p>Erro ao carregar modelo.</p>",
-            None, [], 1, gr.update(visible=False),
-            "", None,
-            gr.update(visible=False), gr.update(visible=False),
-            gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),
-            gr.update(visible=False), gr.update(visible=False),
-            *_valores_reset_secoes_4_a_16(),
-            # Volta ao estado de upload em caso de erro
-            gr.update(visible=True),   # row_upload
-            gr.update(visible=False),  # row_selecao_aba
-            gr.update(visible=False),  # row_pos_carga
-            gr.update(value=""),       # html_nome_arquivo_carregado
-            False,                     # estado_flag_carregamento
-            *[gr.update()] * 4,        # filtro_vars (no-op)
-            # Painel de coordenadas (no-op — .dai isento)
-            gr.update(visible=False), gr.update(value=""),
-            gr.update(choices=[]), gr.update(choices=[]),
-            gr.update(choices=[], value=None), gr.update(choices=[], value=None),
-            gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
-            gr.update(visible=False),  # row_opcao_mapear
-            gr.update(visible=False),  # row_opcao_geocodificar
-        )
-
-    colunas_numericas = obter_colunas_numericas(df)
-    gmt_minus_3 = timezone(timedelta(hours=-3))
-    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
-    mapa_html_val = criar_mapa(df)
-
-    # --- Passo 2: Simula "Aplicar Seleção" (seções 5-9) ---
-    r = aplicar_selecao_callback(df, coluna_y, colunas_x, outliers_excluidos, dicotomicas, codigo_alocado, percentuais)
-    # r: [df_filtrado, tabela_est, html_micro, plot_disp, slider_coef, slider_f,
-    #     busca_html, resultados, btn1-5(5), secoes5-9 headers/accordions(10), campos_transf(66)]
-
-    # --- Passo 3: Sobrescreve dropdowns de transformação com valores do .dai ---
-    campos_transf = list(r[23:89])  # 66 itens: y_row(1)+y_col(1)+y_label(1)+rows(3)+columns(20)+labels(20)+dropdowns(20)
-    n_rows = (MAX_VARS_X + 7) // 8
-    dropdown_offset = 3 + n_rows + MAX_VARS_X + MAX_VARS_X  # 3 + 3 + 20 + 20 = 46
-    for i, col in enumerate(colunas_x):
-        if i < MAX_VARS_X:
-            # Dicotômicas e percentuais: travar. Variáveis categóricas codificadas: livres.
-            travar = col in dicotomicas or col in percentuais
-            campos_transf[dropdown_offset + i] = gr.update(
-                value=transformacoes_x.get(col, "(x)"),
-                interactive=not travar,
-                visible=True
-            )
-
-    # --- Passo 4: Simula "Ajustar Modelo" (seções 10-16) ---
-    df_para_ajuste = r[0] if r[0] is not None else df  # df filtrado (sem outliers excluídos)
-    dropdown_vals = [transformacoes_x.get(colunas_x[i], "(x)") if i < len(colunas_x) else "(x)"
-                     for i in range(MAX_VARS_X)]
-    m = ajustar_modelo_callback(df_para_ajuste, coluna_y, colunas_x, transformacao_y, outliers_excluidos, dicotomicas, codigo_alocado, percentuais, *dropdown_vals)
-    # m[0]:resultado  [1]:diag  [2]:coef  [3]:obs_calc  [4]:plot_disp  [5]:dropdown
-    # m[6-10]:plots  [11]:metricas  [12]:est_metricas  [13]:resumo
-    # m[14]:estado_avaliacoes
-    # m[15-16]:h10,a10  [17-18]:h11,a11  [19-20]:h12,a12  [21-22]:h13,a13
-    # m[23-24]:h14,a14  [25-26]:h15_aval,a15_aval  [27-28]:h16_exp,a16_exp
-    # m[29-32]:filtro_vars
-
-    n_aval_rows = MAX_VARS_X // 4  # 5
-
-    return (
-        # --- Seções 1-3: dados básicos ---
-        df,                                                     # estado_df
-        msg,                                                    # status
-        gr.update(),                                            # dropdown_aba (no-op)
-        gr.update(choices=colunas_numericas, value=coluna_y),   # dropdown_y
-        arredondar_df(df),                                      # tabela_dados
-        r[1],                                                   # tabela_estatisticas (de aplicar_selecao)
-        gr.update(choices=colunas_numericas, value=colunas_x),  # checkboxes_x
-        mapa_html_val,                                          # mapa
-        r[0],                                                   # estado_df_filtrado (de aplicar_selecao)
-        outliers_excluidos,                                     # estado_outliers_anteriores
-        1,                                                      # estado_iteracao
-        gr.update(visible=bool(outliers_excluidos)),             # accordion_outliers_anteriores
-        html_outliers_content,                                  # html_outliers_anteriores
-        None,                                                   # estado_arquivo_temp
-        gr.update(visible=True, value=criar_header_secao(2, "Visualizar Dados", timestamp)),
-        gr.update(visible=True, open=True),                     # accordion_secao_2
-        gr.update(choices=["Visualização Padrão"] + colunas_numericas, value="Visualização Padrão"),
-        gr.update(visible=True),                                # header_secao_3
-        gr.update(visible=True, open=True),                     # accordion_secao_3
-        # --- States seções 4-16 ---
-        m[0],                                                   # estado_modelo (de ajustar)
-        m[12],                                                  # estado_metricas (de ajustar)
-        r[7],                                                   # estado_resultados_busca (de aplicar_selecao)
-        m[14],                                                  # estado_avaliacoes (de ajustar — reset [])
-        # --- Seção 4: seleção de variáveis ---
-        gr.update(visible=True, value=criar_header_secao(4, "Selecionar Variáveis Independentes", timestamp)),
-        gr.update(visible=True, open=True),                     # accordion_secao_4
-        gr.update(choices=list(colunas_x), value=list(dicotomicas), visible=True),           # checkboxes_dicotomicas
-        gr.update(choices=list(colunas_x), value=list(codigo_alocado), visible=True),      # checkboxes_codigo_alocado
-        gr.update(choices=list(colunas_x), value=list(percentuais), visible=True),         # checkboxes_percentuais
-        gr.update(value="", visible=False),                                                  # html_aviso_multicolinearidade
-        # --- Seções 5-9: headers/accordions (de aplicar_selecao) ---
-        r[13], r[14],                                           # header_secao_5, accordion_secao_5
-        r[15], r[16],                                           # header_secao_6, accordion_secao_6
-        r[2],                                                   # html_micronumerosidade
-        r[17], r[18],                                           # header_secao_7, accordion_secao_7
-        r[3],                                                   # plot_dispersao
-        r[19], r[20],                                           # header_secao_8, accordion_secao_8
-        r[4], r[5],                                             # slider_grau_coef, slider_grau_f
-        r[6],                                                   # busca_html
-        r[21], r[22],                                           # header_secao_9, accordion_secao_9
-        gr.update(value=transformacao_y),                        # transformacao_y dropdown (do .dai)
-        r[8], r[9], r[10], r[11], r[12],                       # btn_adotar 1-5
-        # --- Campos de transformação (com dropdowns sobrescritos) ---
-        *campos_transf,
-        # --- Seções 10-16 (de ajustar_modelo_callback) ---
-        m[15], m[16],                                           # header_secao_10, accordion_secao_10
-        m[5],                                                   # dropdown_tipo_grafico_dispersao
-        m[4],                                                   # plot_dispersao_transf
-        m[17], m[18],                                           # header_secao_11, accordion_secao_11
-        m[1],                                                   # diagnosticos_html
-        m[2],                                                   # tabela_coef
-        m[3],                                                   # tabela_obs_calc
-        m[19], m[20],                                           # header_secao_12, accordion_secao_12
-        m[6], m[7], m[8], m[9], m[10],                         # plots: obs_calc, resid, hist, cook, corr
-        m[21], m[22],                                           # header_secao_13, accordion_secao_13
-        m[11],                                                  # tabela_metricas
-        m[23], m[24],                                           # header_secao_14, accordion_secao_14
-        html_outliers_content,                                  # html_outliers_sec14
-        "",                                                     # outliers_texto
-        "",                                                     # reincluir_texto
-        m[13],                                                  # txt_resumo_outliers
-        # --- Seção 15: Avaliação de Imóvel ---
-        m[25], m[26],                                           # header_secao_15, accordion_secao_15
-        *[gr.update(visible=False) for _ in range(n_aval_rows)],  # aval_rows (populados pelo .then)
-        *[gr.update(visible=False, value=None, label="") for _ in range(MAX_VARS_X)],  # aval_inputs (populados pelo .then)
-        "",                                                     # resultado_avaliacao_html
-        gr.update(choices=[], value=None),                      # dropdown_base_avaliacao
-        "",                                                     # excluir_aval_trigger
-        gr.update(value=None, visible=False),                   # download_avaliacoes_file
-        # --- Seção 16: Exportar Modelo ---
-        m[27], m[28],                                           # header_secao_16, accordion_secao_16
-        gr.update(value=""),                                    # nome_arquivo
-        gr.update(value=""),                                    # status_exportar
-        # Transição para estado C (pós-carregamento)
-        gr.update(visible=False),                               # row_upload
-        gr.update(visible=False),                               # row_selecao_aba
-        gr.update(visible=True),                                # row_pos_carga
-        gr.update(value=html_nome),                                 # html_nome_arquivo_carregado
-        2,                                                      # estado_flag_carregamento (contador: 2 side-effects esperados)
-        m[29], m[30], m[31], m[32],                             # filtro_vars (choices com colunas originais)
-        # Painel de coordenadas (no-op — .dai isento)
-        gr.update(visible=False), gr.update(value=""),
-        gr.update(choices=[]), gr.update(choices=[]),
-        gr.update(choices=[], value=None), gr.update(choices=[], value=None),
-        gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
-        gr.update(visible=False),  # row_opcao_mapear
-        gr.update(visible=False),  # row_opcao_geocodificar
-    )
-
-
-def carregar_dados_do_arquivo(caminho_arquivo, nome_aba, nome_arquivo_exibicao=""):
-    """Carrega dados de um arquivo, opcionalmente de uma aba específica.
-
-    Args:
-        caminho_arquivo: Caminho do arquivo a carregar
-        nome_aba: Nome da aba a carregar (apenas para Excel)
-        nome_arquivo_exibicao: Nome do arquivo para exibir na interface pós-carregamento
-
-    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
-    """
-    df, msg, sucesso = carregar_arquivo(caminho_arquivo, nome_aba)
-
-    if not sucesso:
-        return (
-            None,  # estado_df
-            msg,   # status
-            gr.update(),  # dropdown_aba
-            gr.update(choices=[], value=None),  # dropdown_y
-            None,  # tabela_dados
-            None,  # tabela_estatisticas
-            gr.update(choices=[]),  # checkboxes_x
-            "<p>Carregue um arquivo para ver o mapa.</p>",  # mapa
-            None,  # estado_df_filtrado
-            [],    # estado_outliers_anteriores
-            1,     # estado_iteracao
-            gr.update(visible=False),  # accordion_outliers_anteriores
-            "",                        # html_outliers_anteriores
-            None,  # estado_arquivo_temp
-            # Seções 2 e 3 - ocultas quando erro
-            gr.update(visible=False),  # header_secao_2
-            gr.update(visible=False),  # accordion_secao_2
-            gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),  # dropdown_mapa_var
-            gr.update(visible=False),  # header_secao_3
-            gr.update(visible=False),  # accordion_secao_3
-            # Reset seções 4-16
-            *_valores_reset_secoes_4_a_16(),
-            # Volta ao estado de upload em caso de erro
-            gr.update(visible=True),   # row_upload
-            gr.update(visible=False),  # row_selecao_aba
-            gr.update(visible=False),  # row_pos_carga
-            gr.update(value=""),       # html_nome_arquivo_carregado
-            False,                     # estado_flag_carregamento
-            *[gr.update()] * 4,        # filtro_vars (no-op)
-            # Painel de coordenadas (no-op — erro)
-            gr.update(visible=False), gr.update(value=""),
-            gr.update(choices=[]), gr.update(choices=[]),
-            gr.update(choices=[], value=None), gr.update(choices=[], value=None),
-            gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
-            gr.update(visible=False),  # row_opcao_mapear
-            gr.update(visible=False),  # row_opcao_geocodificar
-        )
-
-    # Verificar e padronizar coordenadas
-    tem_coords, col_lat, col_lon = verificar_coords(df)
-    todas_colunas = df.columns.tolist()
-
-    if tem_coords:
-        df = padronizar_coords(df, col_lat, col_lon)
-        aviso_coords_html = ""
-        cdlog_auto = None
-        num_auto = None
-    else:
-        cdlog_auto, num_auto = auto_detectar_colunas_geo(df)
-        n = len(df)
-        aviso_coords_html = (
-            '<div style="background:#f8d7da;border:1px solid #f5c2c7;border-radius:8px;'
-            f'padding:10px 14px;margin-bottom:8px"><strong>⚠️ Colunas lat/lon não '
-            f'encontradas</strong> — {n} registro(s) sem coordenadas padronizadas.<br>'
-            '</div>'
-        )
-
-    # Identifica colunas (após padronização de coords)
-    colunas_numericas = obter_colunas_numericas(df)
-    coluna_y_padrao = identificar_coluna_y_padrao(df)
-
-    # Variáveis X padrão: todas exceto Y
-    colunas_x_padrao = [col for col in colunas_numericas if col != coluna_y_padrao]
-
-    # NÃO calcula estatísticas no carregamento - apenas ao clicar em "Aplicar Seleção"
-
-    # Mapa
-    mapa_html = criar_mapa(df)
-
-    # Timestamp para seção 2
-    gmt_minus_3 = timezone(timedelta(hours=-3))
-    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
-
-    return (
-        df,  # estado_df
-        msg,  # status
-        gr.update(),  # dropdown_aba (no-op)
-        gr.update(choices=colunas_numericas, value=coluna_y_padrao),  # dropdown_y
-        arredondar_df(df),  # tabela_dados
-        gr.update(value=None),  # tabela_estatisticas - NÃO mostra até clicar em Aplicar Seleção
-        gr.update(choices=colunas_numericas, value=[]),  # checkboxes_x (nenhuma marcada por padrão)
-        mapa_html,  # mapa
-        df,  # estado_df_filtrado (inicia com dados completos)
-        [],  # estado_outliers_anteriores
-        1,   # estado_iteracao
-        gr.update(visible=False),  # accordion_outliers_anteriores
-        "",                        # html_outliers_anteriores
-        None,  # estado_arquivo_temp
-        # Seções 2 e 3 — header sempre visível; accordion oculto até coords resolvidas
-        gr.update(visible=True, value=criar_header_secao(2, "Visualizar Dados", timestamp) if tem_coords else criar_header_secao(2, "Visualizar Dados")),  # header_secao_2
-        gr.update(visible=tem_coords, open=True),  # accordion_secao_2
-        gr.update(choices=["Visualização Padrão"] + colunas_numericas, value="Visualização Padrão"),  # dropdown_mapa_var
-        gr.update(visible=True),                   # header_secao_3
-        gr.update(visible=tem_coords, open=True),  # accordion_secao_3
-        # Reset seções 4-16
-        *_valores_reset_secoes_4_a_16(),
-        # Transição para estado C (pós-carregamento)
-        gr.update(visible=False),   # row_upload
-        gr.update(visible=False),   # row_selecao_aba
-        gr.update(visible=True),    # row_pos_carga
-        gr.update(value=f"<h3>{nome_arquivo_exibicao}</h3>"),  # html_nome_arquivo_carregado
-        2,                          # estado_flag_carregamento (contador: 2 side-effects esperados)
-        *[gr.update()] * 4,         # filtro_vars (no-op — seções 13-14 ocultas)
-        # Painel de coordenadas (Estado D) — mostrado apenas se coords ausentes
-        gr.update(visible=not tem_coords),                                                      # row_coords_panel
-        gr.update(value=aviso_coords_html),                                                     # html_aviso_coords
-        gr.update(choices=todas_colunas if not tem_coords else []),                             # dropdown_col_lat_manual
-        gr.update(choices=todas_colunas if not tem_coords else []),                             # dropdown_col_lon_manual
-        gr.update(choices=todas_colunas if not tem_coords else [], value=cdlog_auto),           # dropdown_cdlog_geo
-        gr.update(choices=todas_colunas if not tem_coords else [], value=num_auto),             # dropdown_num_geo
-        gr.update(visible=True),                                                                # row_escolha_opcao — reset para tela de escolha
-        gr.update(visible=False),                                                               # row_opcao_mapear
-        gr.update(visible=False),                                                               # row_opcao_geocodificar
-    )
-
-
-# ============================================================
-# LIMPAR HISTÓRICO
-# ============================================================
-
-def limpar_historico_callback(df_original):
-    """Limpa o histórico de outliers e reinicia do zero.
-    Reseta tudo como se o arquivo tivesse acabado de ser carregado.
-
-    CONTRACT: Retorna 169 itens para btn_limpar_historico.click (app.py:criar_aba).
-    Se alterar, atualizar: app.py (outputs de btn_limpar_historico.click).
-    """
-    mapa = criar_mapa(df_original)
-
-    return (
-        [],                       # estado_outliers_anteriores (vazio)
-        1,                        # estado_iteracao (reinicia)
-        df_original,              # estado_df_filtrado (dados originais)
-        arredondar_df(df_original),     # tabela_dados
-        gr.update(value=None),    # tabela_estatisticas (limpa)
-        mapa,                     # mapa_html
-        "",                       # html_outliers_anteriores
-        gr.update(visible=False), # accordion_outliers_anteriores (esconde)
-        gr.update(value=criar_header_secao(2, "Visualizar Dados")),  # header_secao_2
-        *_valores_reset_secoes_4_a_16(),  # reset completo seções 4-15
-        *[gr.update()] * 4,         # filtro_vars (no-op — seções ocultas após reset)
-    )

backend/app/core/elaboracao/modelo.py

@@ -1,991 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-modelo.py - Ajuste de modelo OLS, transformações e seleção de variáveis.
-
-Callbacks que lidam com a lógica do modelo estatístico:
-seleção X/Y, ajuste OLS, busca de transformações, exportação.
-"""
-
-import gradio as gr
-import pandas as pd
-from datetime import datetime, timezone, timedelta
-
-from .formatadores import (
-    criar_header_secao,
-    formatar_diagnosticos_html,
-    formatar_busca_html,
-    formatar_micronumerosidade_html,
-    formatar_aviso_multicolinearidade,
-)
-from .core import (
-    obter_colunas_numericas,
-    calcular_estatisticas_variaveis,
-    ajustar_modelo,
-    buscar_melhores_transformacoes,
-    testar_micronumerosidade,
-    detectar_dicotomicas,
-    detectar_codigo_alocado,
-    detectar_percentuais,
-    exportar_modelo_dai,
-    avaliar_imovel,
-    exportar_avaliacoes_excel,
-    verificar_multicolinearidade,
-)
-from .formatadores import formatar_avaliacao_html
-from .charts import (
-    criar_graficos_dispersao,
-    criar_graficos_dispersao_residuos,
-    criar_painel_diagnostico,
-    criar_matriz_correlacao,
-)
-
-
-# ============================================================
-# CONSTANTES
-# ============================================================
-
-MAX_VARS_X = 20
-
-
-# ============================================================
-# UTILITÁRIOS DE TRANSFORMAÇÃO
-# ============================================================
-
-def obter_transformacoes_dos_dropdowns(colunas_x, *valores_dropdowns):
-    """Coleta transformações dos valores dos dropdowns."""
-    transformacoes = {}
-    for i, col in enumerate(colunas_x):
-        if i < len(valores_dropdowns) and valores_dropdowns[i]:
-            transformacoes[col] = valores_dropdowns[i]
-        else:
-            transformacoes[col] = "(x)"
-    return transformacoes
-
-
-def atualizar_campos_transformacoes(df, colunas_x, dicotomicas=None, coluna_y=None):
-    """Atualiza visibilidade e valores dos campos de transformação.
-
-    CONTRACT: Retorna 66 itens para transf_y_row(1) + transf_y_col(1) + transf_y_label(1)
-    + transf_x_rows(3) + transf_x_columns(20) + transf_x_labels(20) + transf_x_dropdowns(20).
-    Se alterar, atualizar: app.py (outputs de checkboxes_x.change e btn_aplicar_selecao_x.click)
-    + _atualizar_campos_transformacoes_com_flag (neste arquivo)
-    + aplicar_selecao_callback (neste arquivo, campos_vazios).
-    """
-    n_rows = (MAX_VARS_X + 7) // 8  # 3 rows (8 cards por linha)
-
-    # Y card updates
-    if coluna_y and df is not None and colunas_x:
-        y_label_html = f'<span class="transf-label-text transf-label-y">{coluna_y} (Y)</span>'
-        y_updates = [
-            gr.update(visible=True),                            # transf_y_row
-            gr.update(visible=True),                            # transf_y_col
-            gr.update(value=y_label_html, visible=True),        # transf_y_label
-        ]
-    else:
-        y_updates = [
-            gr.update(visible=False),                           # transf_y_row
-            gr.update(visible=False),                           # transf_y_col
-            gr.update(value="", visible=False),                 # transf_y_label
-        ]
-
-    if df is None or not colunas_x:
-        # Esconde todos
-        row_updates = [gr.update(visible=False)] * n_rows
-        column_updates = [gr.update(visible=False)] * MAX_VARS_X
-        label_updates = [gr.update(value="", visible=False)] * MAX_VARS_X
-        dropdown_updates = [gr.update(value="(x)", interactive=True, visible=False)] * MAX_VARS_X
-        return y_updates + row_updates + column_updates + label_updates + dropdown_updates
-
-    if dicotomicas is None:
-        dicotomicas = detectar_dicotomicas(df, colunas_x)
-
-    # Updates para rows (visibilidade) - 8 por linha
-    row_updates = []
-    for i in range(n_rows):
-        idx_base = i * 8
-        visivel = idx_base < len(colunas_x)
-        row_updates.append(gr.update(visible=visivel))
-
-    # Updates para columns, labels e dropdowns
-    column_updates = []
-    label_updates = []
-    dropdown_updates = []
-
-    for i in range(MAX_VARS_X):
-        if i < len(colunas_x):
-            col = colunas_x[i]
-            eh_marcada = col in dicotomicas
-            # Só trava transformação se variável marcada E tem valores zero (dicotômica 0/1)
-            travar = False
-            if eh_marcada and col in df.columns:
-                valores_col = set(df[col].dropna().unique())
-                travar = 0 in valores_col or 0.0 in valores_col
-            column_updates.append(gr.update(visible=True))
-            label_updates.append(gr.update(value=f'<span class="transf-label-text">{col}</span>', visible=True))
-            dropdown_updates.append(gr.update(
-                value="(x)",
-                interactive=not travar,
-                visible=True
-            ))
-        else:
-            column_updates.append(gr.update(visible=False))
-            label_updates.append(gr.update(value="", visible=False))
-            dropdown_updates.append(gr.update(value="(x)", interactive=True, visible=False))
-
-    return y_updates + row_updates + column_updates + label_updates + dropdown_updates
-
-
-def _atualizar_campos_transformacoes_com_flag(df, colunas_x, flag_carregamento, coluna_y=None):
-    """Wrapper que pula reset de transformações durante carregamento programático.
-
-    CONTRACT: Retorna 70 itens (66 campos + estado_flag_carregamento + 3 checkboxes).
-    Se alterar, atualizar: app.py (outputs de checkboxes_x.change).
-    """
-    # Flag é um contador inteiro: decrementa a cada side-effect processado
-    if flag_carregamento:
-        n_items = 3 + (MAX_VARS_X + 7) // 8 + MAX_VARS_X + MAX_VARS_X + MAX_VARS_X  # 66
-        return [gr.update() for _ in range(n_items)] + [max(0, int(flag_carregamento) - 1), gr.update(), gr.update(), gr.update()]
-
-    if df is not None and colunas_x:
-        dicotomicas_01 = detectar_dicotomicas(df, colunas_x)
-        codigo_alocado = detectar_codigo_alocado(df, colunas_x)
-        percentuais = detectar_percentuais(df, colunas_x)
-    else:
-        dicotomicas_01 = []
-        codigo_alocado = []
-        percentuais = []
-
-    todas_marcadas = dicotomicas_01 + codigo_alocado + percentuais
-    campos = atualizar_campos_transformacoes(df, colunas_x, todas_marcadas, coluna_y=coluna_y)
-    choices = list(colunas_x) if colunas_x else []
-    vis = bool(colunas_x)
-    return campos + [
-        False,
-        gr.update(choices=choices, value=dicotomicas_01, visible=vis),
-        gr.update(choices=choices, value=codigo_alocado, visible=vis),
-        gr.update(choices=choices, value=percentuais, visible=vis),
-    ]
-
-
-# ============================================================
-# HANDLERS DE MUDANÇA DE SELEÇÃO
-# ============================================================
-
-def ao_mudar_tipo_grafico(tipo, resultado_modelo):
-    """Atualiza o gráfico de dispersão com base na seleção do dropdown."""
-    if not resultado_modelo:
-        return None
-
-    try:
-        X_transf = resultado_modelo["X_transformado"]
-
-        if "Resíduo" in tipo:
-            # Gráfico X vs Resíduos
-            tabela = resultado_modelo.get("tabela_obs_calc")
-            if tabela is not None and "Resíduo Pad." in tabela.columns:
-                residuos = tabela["Resíduo Pad."].values
-                return criar_graficos_dispersao_residuos(X_transf, residuos)
-            else:
-                return None
-        else:
-            # Gráfico X vs Y (Padrão)
-            y_transf = resultado_modelo["y_transformado"]
-            return criar_graficos_dispersao(X_transf, y_transf)
-
-    except Exception as e:
-        print(f"Erro ao atualizar gráfico: {e}")
-        return None
-
-
-def ao_mudar_y_sem_estatisticas(df, coluna_y, flag_carregamento=False, mostrar_secao_x=False):
-    """Callback quando variável y é alterada (sem calcular estatísticas).
-
-    Apenas atualiza os checkboxes de X disponíveis.
-    As estatísticas são calculadas apenas ao clicar em 'Aplicar Seleção' na seção 4.
-
-    Args:
-        df: DataFrame com os dados
-        coluna_y: Nome da coluna Y selecionada
-        flag_carregamento: Se True, mudança veio de carregamento programático (skip reset)
-        mostrar_secao_x: Se True, mostra a seção 4 (usado pelo botão Aplicar da seção 3)
-    """
-    # Se mudança veio de carregamento programático, não sobrescrever valores
-    # Flag é um contador inteiro: decrementa a cada side-effect processado
-    if flag_carregamento:
-        return (
-            gr.update(),            # checkboxes_x — manter valor do carregamento
-            gr.update(),            # header_secao_4 — manter visibilidade
-            gr.update(),            # accordion_secao_4 — manter visibilidade
-            max(0, int(flag_carregamento) - 1),  # estado_flag_carregamento — decrementar
-        )
-
-    if df is None or coluna_y is None:
-        return (
-            gr.update(choices=[]),     # checkboxes_x
-            gr.update(visible=False),  # header_secao_4
-            gr.update(visible=False),  # accordion_secao_4
-            False,                     # estado_flag_carregamento
-        )
-
-    # Lista de X disponíveis (exclui y) - todas marcadas por padrão
-    colunas_x = [col for col in obter_colunas_numericas(df) if col != coluna_y]
-
-    return (
-        gr.update(choices=colunas_x, value=colunas_x),  # checkboxes_x
-        gr.update(visible=mostrar_secao_x),             # header_secao_4
-        gr.update(visible=mostrar_secao_x, open=mostrar_secao_x),  # accordion_secao_4
-        False,                                          # estado_flag_carregamento
-    )
-
-
-# ============================================================
-# ESTATÍSTICAS
-# ============================================================
-
-def atualizar_estatisticas_auto(df_filtrado, coluna_y, colunas_x):
-    """Recalcula estatísticas automaticamente e retorna timestamp.
-
-    CONTRACT: Retorna 2 itens (estatisticas, timestamp).
-    Se alterar, atualizar: outliers.py (reiniciar_iteracao_callback, destructuring).
-    """
-    if df_filtrado is None or coluna_y is None:
-        return None, None
-
-    # Filtra apenas colunas selecionadas + Y
-    colunas_usar = [coluna_y] + list(colunas_x) if colunas_x else [coluna_y]
-    colunas_disponiveis = [c for c in colunas_usar if c in df_filtrado.columns]
-
-    if not colunas_disponiveis:
-        return None, None
-
-    estatisticas = calcular_estatisticas_variaveis(df_filtrado, coluna_y, colunas=colunas_disponiveis)
-    gmt_minus_3 = timezone(timedelta(hours=-3))
-    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
-
-    return estatisticas.round(4), timestamp
-
-
-# ============================================================
-# CALLBACKS PRINCIPAIS
-# ============================================================
-
-def ajustar_modelo_callback(df, coluna_y, colunas_x, transformacao_y, outliers_anteriores, dicotomicas, codigo_alocado, percentuais, *valores_dropdowns):
-    """Callback para ajustar o modelo e calcular métricas de outliers.
-
-    CONTRACT: Retorna 33 itens para _outputs_ajustar (app.py:criar_aba).
-    Se alterar, atualizar: _outputs_ajustar em app.py + carregamento.py (indices em carregar_dados_de_dai).
-    """
-    # Variáveis disponíveis para filtro (métricas + todas as colunas originais do DataFrame)
-    colunas_metricas = {"Observado", "Calculado", "Resíduo", "Resíduo Pad.", "Resíduo Stud.", "Cook"}
-    colunas_originais = [c for c in df.columns if c not in colunas_metricas] if df is not None else []
-    variaveis_filtro = ["Resíduo Pad.", "Resíduo Stud.", "Cook"] + colunas_originais
-    filtro_var_updates = [gr.update(choices=variaveis_filtro)] * 4
-
-    # Updates para seções 10-16 ocultas (7 seções × 2 = 14 itens)
-    secoes_ocultas = (
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_10, accordion_secao_10
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_11, accordion_secao_11
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_12, accordion_secao_12
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_13, accordion_secao_13
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_14, accordion_secao_14
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_15, accordion_secao_15 (Avaliação)
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_16, accordion_secao_16 (Exportar)
-    )
-
-    if df is None or coluna_y is None or not colunas_x:
-        return (
-            None,  # estado_modelo
-            "",  # diagnosticos_html
-            None,  # tabela_coef
-            None,  # tabela_obs_calc
-            None,  # plot_dispersao_transf
-            gr.update(visible=False),  # dropdown_tipo_grafico_dispersao
-            None, None, None, None, None,  # gráficos
-            None,  # tabela_metricas
-            None,  # estado_metricas
-            f"Excluídos: {len(outliers_anteriores) if outliers_anteriores else 0} | A excluir: 0 | A reincluir: 0 | Total: {len(outliers_anteriores) if outliers_anteriores else 0}",  # txt_resumo_outliers
-            [],  # estado_avaliacoes (reset)
-            *secoes_ocultas,  # seções 10-16 ocultas
-            *filtro_var_updates  # atualiza dropdowns de filtro
-        )
-
-    # Extrai transformações dos dropdowns
-    transformacoes_x = obter_transformacoes_dos_dropdowns(colunas_x, *valores_dropdowns)
-
-    # Ajusta modelo
-    resultado = ajustar_modelo(
-        df, coluna_y, colunas_x,
-        transformacao_y, transformacoes_x
-    )
-
-    if resultado is None:
-        return (
-            None,  # estado_modelo
-            "",  # diagnosticos_html
-            None,  # tabela_coef
-            None,  # tabela_obs_calc
-            None,  # plot_dispersao_transf
-            gr.update(visible=False),  # dropdown_tipo_grafico_dispersao
-            None, None, None, None, None,  # gráficos
-            None,  # tabela_metricas
-            None,  # estado_metricas
-            f"Outliers anteriores: {len(outliers_anteriores) if outliers_anteriores else 0} | Excluir: 0 | Reincluir: 0 | Total: {len(outliers_anteriores) if outliers_anteriores else 0}",
-            [],  # estado_avaliacoes (reset)
-            *secoes_ocultas,  # seções 10-16 ocultas
-            *filtro_var_updates  # atualiza dropdowns de filtro
-        )
-
-    # Formata diagnósticos
-    diagnosticos_html = formatar_diagnosticos_html(resultado["diagnosticos"])
-    gmt_minus_3 = timezone(timedelta(hours=-3))
-    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
-
-    # Gráficos de dispersão com variáveis transformadas
-    try:
-        X_transf = resultado["X_transformado"]
-        y_transf = resultado["y_transformado"]
-        fig_dispersao_transf = criar_graficos_dispersao(X_transf, y_transf)
-    except Exception as e:
-        print(f"Erro ao gerar gráficos de dispersão transformados: {e}")
-        fig_dispersao_transf = None
-
-    # Gr��ficos de diagnóstico
-    graficos = criar_painel_diagnostico(resultado)
-
-    # Correlação (com variáveis transformadas)
-    try:
-        X_transf_corr = resultado["X_transformado"].copy()
-        y_transf_corr = resultado["y_transformado"].copy()
-
-        # Cria DataFrame temporário para correlação
-        df_corr_temp = X_transf_corr
-        # Adiciona y (garantindo nome correto)
-        df_corr_temp[coluna_y] = y_transf_corr
-
-        colunas_corr = [coluna_y] + list(colunas_x)
-        fig_corr = criar_matriz_correlacao(df_corr_temp, colunas_corr, coluna_y=coluna_y)
-    except Exception as e:
-        print(f"Erro ao gerar matriz de correlação transformada: {e}")
-        fig_corr = None
-
-    # Extrai métricas de outliers da tabela_obs_calc (já contém resíduos, Cook, etc.)
-    tabela_metricas = resultado["tabela_obs_calc"].copy()
-
-    # Para o estado de filtros:
-    # 1. Usa set_index para que o índice do DataFrame seja os índices originais
-    # 2. Adiciona as variáveis X para permitir filtros por variáveis
-    tabela_metricas_estado = tabela_metricas.set_index("Índice")
-
-    # Adiciona todas as colunas originais ao estado para filtros
-    indices_usados = resultado["indices_usados"]
-    df_filtrado = df.loc[indices_usados]
-    colunas_novas = {
-        col: df_filtrado[col].values
-        for col in df.columns
-        if col not in tabela_metricas_estado.columns
-    }
-    if colunas_novas:
-        tabela_metricas_estado = pd.concat(
-            [tabela_metricas_estado, pd.DataFrame(colunas_novas, index=tabela_metricas_estado.index)],
-            axis=1
-        )
-
-    # Resumo de outliers
-    n_anteriores = len(outliers_anteriores) if outliers_anteriores else 0
-    resumo = f"Excluídos: {n_anteriores} | A excluir: 0 | A reincluir: 0 | Total: {n_anteriores}"
-
-    # Updates para seções 10-16 visíveis com timestamp nos headers (7 seções × 2 = 14 itens)
-    secoes_visiveis = (
-        gr.update(visible=True, value=criar_header_secao(10, "Gráficos de Dispersão com Modelo Ajustado", timestamp)),  # header_secao_10
-        gr.update(visible=True, open=True),  # accordion_secao_10
-        gr.update(visible=True, value=criar_header_secao(11, "Diagnóstico de Modelo", timestamp)),  # header_secao_11
-        gr.update(visible=True, open=True),  # accordion_secao_11
-        gr.update(visible=True, value=criar_header_secao(12, "Gráficos de Diagnóstico do Modelo", timestamp)),  # header_secao_12
-        gr.update(visible=True, open=True),  # accordion_secao_12
-        gr.update(visible=True, value=criar_header_secao(13, "Analisar Outliers", timestamp)),  # header_secao_13
-        gr.update(visible=True, open=True),  # accordion_secao_13
-        gr.update(visible=True, value=criar_header_secao(14, "Exclusão ou Reinclusão de Outliers", timestamp)),  # header_secao_14
-        gr.update(visible=True, open=True),  # accordion_secao_14
-        gr.update(visible=True, value=criar_header_secao(15, "Avaliação de Imóvel", timestamp)),  # header_secao_15
-        gr.update(visible=True, open=True),  # accordion_secao_15
-        gr.update(visible=True, value=criar_header_secao(16, "Exportar Modelo", timestamp)),  # header_secao_16
-        gr.update(visible=True, open=True),  # accordion_secao_16
-    )
-
-    resultado["dicotomicas"] = list(dicotomicas) if dicotomicas else []
-    resultado["codigo_alocado"] = list(codigo_alocado) if codigo_alocado else []
-    resultado["percentuais"] = list(percentuais) if percentuais else []
-
-    return (
-        resultado,
-        diagnosticos_html,
-        resultado["tabela_coef"].round(4),
-        resultado["tabela_obs_calc"].round(4),
-        fig_dispersao_transf,  # plot_dispersao_transf
-        gr.update(value="Variáveis Independentes Transformadas X Variável Dependente Transformada", visible=True),  # dropdown_tipo_grafico_dispersao
-        graficos.get("obs_calc"),
-        graficos.get("residuos"),
-        graficos.get("histograma"),
-        graficos.get("cook"),
-        fig_corr,
-        tabela_metricas.round(4),  # tabela_metricas (para exibição - com coluna Índice)
-        tabela_metricas_estado,  # estado_metricas (com set_index - para filtros)
-        resumo,  # txt_resumo_outliers
-        [],  # estado_avaliacoes (reset ao re-ajustar)
-        *secoes_visiveis,  # seções 10-16 visíveis
-        *filtro_var_updates  # atualiza dropdowns de filtro
-    )
-
-
-def buscar_transformacoes_callback(df, coluna_y, colunas_x, dicotomicas=None, codigo_alocado=None, percentuais=None, grau_min_coef=1, grau_min_f=0):
-    """Callback para busca automática de transformações.
-
-    CONTRACT: Retorna 8 itens (html, resultados, timestamp, btn1..btn5).
-    Se alterar, atualizar: outliers.py (reiniciar_iteracao_callback, destructuring)
-    + app.py (outputs de btn_buscar_transf.click).
-    """
-    btn_hidden = [gr.update(visible=False)] * 5
-
-    if df is None or coluna_y is None or not colunas_x:
-        return ("<p>Selecione as variáveis primeiro.</p>", [], "", *btn_hidden)
-
-    # Verifica se colunas têm dados válidos (não 100% NaN)
-    colunas_vazias = []
-    for col in colunas_x:
-        if col in df.columns and df[col].isna().all():
-            colunas_vazias.append(col)
-
-    if colunas_vazias:
-        msg = f"<p style='color: red;'><b>Erro:</b> As seguintes colunas estão completamente vazias (sem dados): <b>{', '.join(colunas_vazias)}</b></p>"
-        msg += "<p>Selecione apenas variáveis que contenham dados válidos.</p>"
-        return (msg, [], "", *btn_hidden)
-
-    # Verifica se Y tem dados válidos
-    if coluna_y in df.columns and df[coluna_y].isna().all():
-        msg = f"<p style='color: red;'><b>Erro:</b> A variável dependente <b>{coluna_y}</b> está completamente vazia.</p>"
-        return (msg, [], "", *btn_hidden)
-
-    # Fixa dicotômicas e percentuais em (x) — variáveis categóricas codificadas ficam livres
-    transformacoes_fixas = {}
-    if dicotomicas is None:
-        dicotomicas = detectar_dicotomicas(df, colunas_x)
-    if percentuais is None:
-        percentuais = detectar_percentuais(df, colunas_x)
-    for col in (dicotomicas or []) + (percentuais or []):
-        transformacoes_fixas[col] = "(x)"
-
-    # Busca melhores transformações
-    resultados = buscar_melhores_transformacoes(
-        df, coluna_y, colunas_x,
-        transformacoes_fixas=transformacoes_fixas,
-        top_n=5,
-        grau_min_coef=int(grau_min_coef),
-        grau_min_f=int(grau_min_f)
-    )
-
-    if not resultados:
-        msg = (
-            "<p style='color: orange;'><b>Aviso:</b> Nenhuma combinação de transformações resultou "
-            "em todos os coeficientes com ao menos Grau I de significância (p&nbsp;≤&nbsp;30%).</p>"
-            "<p>Considere revisar as variáveis selecionadas ou verificar a qualidade dos dados.</p>"
-        )
-        return (msg, [], "", *btn_hidden)
-
-    html = formatar_busca_html(resultados)
-    gmt_minus_3 = timezone(timedelta(hours=-3))
-    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
-
-    # Atualiza visibilidade dos botões "Adotar"
-    btn_updates = [gr.update(visible=(i < len(resultados))) for i in range(5)]
-
-    return (html, resultados, timestamp, *btn_updates)
-
-
-def aplicar_selecao_callback(df, coluna_y, colunas_x, outliers_anteriores, dicotomicas=None, codigo_alocado=None, percentuais=None):
-    """Aplica seleção de variáveis, atualiza estatísticas e busca transformações automaticamente.
-
-    NÃO calcula métricas de outliers aqui - isso é feito ao ajustar o modelo.
-    Filtra dados excluindo outliers de iterações anteriores.
-    Gera gráficos de dispersão e teste de micronumerosidade.
-    Busca transformações com fallback automático (começa em Grau III/III e reduz se necessário).
-
-    CONTRACT: Retorna 90 itens para btn_aplicar_selecao_x.click (app.py:criar_aba).
-    Se alterar, atualizar: app.py (outputs) + carregamento.py (indices em carregar_dados_de_dai).
-    """
-    n_rows = (MAX_VARS_X + 7) // 8  # 3 rows (8 por linha)
-
-    # Valores padrão quando não há dados
-    campos_vazios = (
-        [gr.update(visible=False)] * 3 +                                   # 3: transf_y_row, transf_y_col, transf_y_label
-        [gr.update(visible=False)] * n_rows +                              # 3: transf_x_rows
-        [gr.update(visible=False)] * MAX_VARS_X +                          # 20: transf_x_columns
-        [gr.update(value="", visible=False)] * MAX_VARS_X +                # 20: transf_x_labels
-        [gr.update(value="(x)", interactive=True, visible=False)] * MAX_VARS_X  # 20: transf_x_dropdowns
-    )
-
-    # Botões de adotar escondidos por padrão
-    btn_hidden = [gr.update(visible=False)] * 5
-
-    # Valores padrão para dispersão e micronumerosidade
-    dispersao_vazio = None
-    micro_vazio = "<p>Clique em 'Aplicar Seleção' para verificar micronumerosidade.</p>"
-
-    # Updates para seções 5-9 ocultas
-    secoes_ocultas = (
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_5, accordion_secao_5
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_6, accordion_secao_6
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_7, accordion_secao_7
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_8, accordion_secao_8
-        gr.update(visible=False), gr.update(visible=False),  # header_secao_9, accordion_secao_9
-    )
-
-    if df is None or coluna_y is None:
-        return (
-            None,  # estado_df_filtrado
-            gr.update(value=None),  # tabela_estatisticas
-            micro_vazio,  # html_micronumerosidade
-            dispersao_vazio,  # plot_dispersao
-            gr.update(),  # slider_grau_coef (no-op)
-            gr.update(),  # slider_grau_f (no-op)
-            "",  # busca_html
-            [],  # estado_resultados_busca
-            *btn_hidden,  # botões adotar
-            *secoes_ocultas,  # seções 5-9 ocultas
-            *campos_vazios,  # campos de transformação
-            gr.update(value="", visible=False),  # html_aviso_multicolinearidade
-        )
-
-    if not colunas_x:
-        return (
-            df,
-            gr.update(value=None),  # tabela_estatisticas
-            micro_vazio,  # html_micronumerosidade
-            dispersao_vazio,  # plot_dispersao
-            gr.update(),  # slider_grau_coef (no-op)
-            gr.update(),  # slider_grau_f (no-op)
-            "",  # busca_html
-            [],  # estado_resultados_busca
-            *btn_hidden,  # botões adotar
-            *secoes_ocultas,  # seções 5-9 ocultas
-            *campos_vazios,  # campos de transformação
-            gr.update(value="", visible=False),  # html_aviso_multicolinearidade
-        )
-
-    # Filtra dados excluindo outliers de iterações anteriores
-    df_filtrado = df.copy()
-    if outliers_anteriores:
-        df_filtrado = df_filtrado.drop(index=outliers_anteriores, errors='ignore')
-
-    # Calcula estatísticas com dados filtrados
-    estatisticas, _ = atualizar_estatisticas_auto(df_filtrado, coluna_y, colunas_x)
-
-    # Timestamp para as novas seções
-    gmt_minus_3 = timezone(timedelta(hours=-3))
-    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
-
-    # Teste de micronumerosidade
-    try:
-        resultado_micro = testar_micronumerosidade(df_filtrado, list(colunas_x),
-            dicotomicas=dicotomicas, codigo_alocado=codigo_alocado)
-        html_micro = formatar_micronumerosidade_html(resultado_micro)
-    except Exception as e:
-        print(f"Erro ao testar micronumerosidade: {e}")
-        html_micro = f"<p style='color: red;'>Erro ao calcular micronumerosidade: {e}</p>"
-
-    # Gera gráficos de dispersão
-    try:
-        X = df_filtrado[list(colunas_x)]
-        y = df_filtrado[coluna_y]
-        fig_dispersao = criar_graficos_dispersao(X, y)
-    except Exception as e:
-        print(f"Erro ao gerar gráficos de dispersão: {e}")
-        fig_dispersao = None
-
-    # Atualiza campos de transformação (junta todas as marcadas para lock)
-    todas_marcadas = (dicotomicas or []) + (codigo_alocado or []) + (percentuais or [])
-    campos_updates = atualizar_campos_transformacoes(df, colunas_x, todas_marcadas, coluna_y=coluna_y)
-
-    # Busca automática de transformações: critério mínimo (Grau I nos coeficientes, sem filtro F)
-    busca_html_result, resultados_busca, _, *btn_updates = buscar_transformacoes_callback(
-        df_filtrado, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais,
-        grau_min_coef=1, grau_min_f=0
-    )
-
-    # Radio buttons refletem o grau mínimo REAL presente nos resultados
-    if resultados_busca:
-        grau_coef_usado = min(
-            min(r.get("graus_coef", {}).values(), default=0)
-            for r in resultados_busca
-        )
-        grau_f_usado = min(r.get("grau_f", 0) for r in resultados_busca)
-    else:
-        grau_coef_usado = 1
-        grau_f_usado = 0
-
-    # Updates para seções 5-9 visíveis com timestamp nos headers
-    secoes_visiveis = (
-        gr.update(visible=True, value=criar_header_secao(5, "Estatísticas das Variáveis Selecionadas", timestamp)),  # header_secao_5
-        gr.update(visible=True, open=True),  # accordion_secao_5
-        gr.update(visible=True, value=criar_header_secao(6, "Teste de Micronumerosidade (NBR 14.653-2)", timestamp)),  # header_secao_6
-        gr.update(visible=True, open=True),  # accordion_secao_6
-        gr.update(visible=True, value=criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes", timestamp)),  # header_secao_7
-        gr.update(visible=True, open=True),  # accordion_secao_7
-        gr.update(visible=True, value=criar_header_secao(8, "Transformações Sugeridas", timestamp)),  # header_secao_8
-        gr.update(visible=True, open=True),  # accordion_secao_8
-        gr.update(visible=True, value=criar_header_secao(9, "Aplicação das Transformações", timestamp)),  # header_secao_9
-        gr.update(visible=True, open=True),  # accordion_secao_9
-    )
-
-    # Verifica multicolinearidade (dados brutos, antes das transformações da seção 9)
-    resultado_multi = verificar_multicolinearidade(df_filtrado, list(colunas_x))
-    html_multi, visivel_multi = formatar_aviso_multicolinearidade(resultado_multi)
-
-    return (
-        df_filtrado,  # estado_df_filtrado
-        gr.update(value=estatisticas),  # tabela_estatisticas
-        html_micro,  # html_micronumerosidade
-        fig_dispersao,  # plot_dispersao
-        gr.update(value=grau_coef_usado),  # slider_grau_coef
-        gr.update(value=grau_f_usado),  # slider_grau_f
-        busca_html_result,  # busca_html
-        resultados_busca,  # estado_resultados_busca
-        *btn_updates,  # botões adotar
-        *secoes_visiveis,  # seções 5-9 visíveis
-        *campos_updates,  # campos de transformação
-        gr.update(value=html_multi, visible=visivel_multi),  # html_aviso_multicolinearidade (item 90)
-    )
-
-
-def adotar_sugestao(indice, resultados, colunas_x):
-    """Preenche os dropdowns com a sugestão selecionada.
-
-    CONTRACT: Retorna 21 itens (1 transf_y + 20 transf_x_dropdowns).
-    Se alterar, atualizar: app.py (outputs de btn_adotar_N.click).
-    """
-    if not resultados or indice >= len(resultados):
-        return [gr.update()] * (1 + MAX_VARS_X)
-
-    sugestao = resultados[indice]
-
-    # Update para transformação de Y
-    updates = [gr.update(value=sugestao["transformacao_y"])]
-
-    # Updates para transformações de X
-    transf_x = sugestao["transformacoes_x"]
-    for i in range(MAX_VARS_X):
-        if i < len(colunas_x):
-            col = colunas_x[i]
-            updates.append(gr.update(value=transf_x.get(col, "(x)")))
-        else:
-            updates.append(gr.update())
-
-    return updates
-
-
-# ============================================================
-# CALLBACKS DE AVALIAÇÃO (Seção 15)
-# ============================================================
-
-N_AVAL_ROWS = MAX_VARS_X // 4  # 5 rows (4 inputs por linha)
-
-
-def popular_campos_avaliacao_callback(estado_modelo, tabela_estatisticas):
-    """Popula inputs da seção 15 com labels dinâmicos após ajuste.
-
-    Chamado via .then() após ajustar_modelo_callback ou carregar .dai.
-
-    CONTRACT: Retorna 27 itens (5 aval_rows + 20 aval_inputs + resultado_html + dropdown_base).
-    Se alterar, atualizar: app.py (_outputs_popular_avaliacao).
-    """
-    rows_hidden = [gr.update(visible=False)] * N_AVAL_ROWS
-    inputs_hidden = [gr.update(visible=False, value=None, label="")] * MAX_VARS_X
-    dropdown_reset = gr.update(choices=[], value=None)
-
-    if estado_modelo is None:
-        return (*rows_hidden, *inputs_hidden, "", dropdown_reset)
-
-    try:
-        colunas_x = estado_modelo["colunas_x"]
-        n_vars = len(colunas_x)
-
-        # Extrair min/max das estatísticas
-        import pandas as pd
-        if tabela_estatisticas is not None and isinstance(tabela_estatisticas, pd.DataFrame):
-            if "Variável" in tabela_estatisticas.columns:
-                est_idx = tabela_estatisticas.set_index("Variável")
-            else:
-                est_idx = tabela_estatisticas
-        else:
-            est_idx = pd.DataFrame()
-
-        # Rows visíveis
-        import math
-        n_rows_vis = math.ceil(n_vars / 4)
-        rows_updates = [gr.update(visible=(r < n_rows_vis)) for r in range(N_AVAL_ROWS)]
-
-        # Inputs com labels dinâmicos
-        dicotomicas = estado_modelo.get("dicotomicas", [])
-        codigo_alocado = estado_modelo.get("codigo_alocado", [])
-        percentuais = estado_modelo.get("percentuais", [])
-        inputs_updates = []
-        for i in range(MAX_VARS_X):
-            if i < n_vars:
-                col = colunas_x[i]
-                if col in dicotomicas:
-                    placeholder = "0 ou 1"
-                elif col in codigo_alocado and col in est_idx.index:
-                    min_val = est_idx.loc[col, "Mínimo"]
-                    max_val = est_idx.loc[col, "Máximo"]
-                    placeholder = f"cód. {int(min_val)} a {int(max_val)}"
-                elif col in percentuais:
-                    placeholder = "0 a 1"
-                elif col in est_idx.index:
-                    min_val = est_idx.loc[col, "Mínimo"]
-                    max_val = est_idx.loc[col, "Máximo"]
-                    placeholder = f"{min_val} — {max_val}"
-                else:
-                    placeholder = ""
-                inputs_updates.append(gr.update(visible=True, value=None, label=col, placeholder=placeholder, interactive=True))
-            else:
-                inputs_updates.append(gr.update(visible=False, value=None, label="", placeholder=""))
-
-        return (*rows_updates, *inputs_updates, "", dropdown_reset)
-
-    except Exception as e:
-        print(f"Erro ao popular campos de avaliação: {e}")
-        return (*rows_hidden, *inputs_hidden, "", dropdown_reset)
-
-
-def avaliar_imovel_callback(estado_modelo, tabela_estatisticas, estado_avaliacoes, indice_base_str, *aval_inputs):
-    """Avalia um imóvel usando o modelo ajustado (seção 15).
-
-    CONTRACT: Retorna 3 itens (resultado_html, estado_avaliacoes, dropdown_update).
-    Se alterar, atualizar: app.py (outputs de btn_calcular_avaliacao.click).
-    """
-    _err = lambda msg: (msg, estado_avaliacoes or [], gr.update())
-    if estado_modelo is None:
-        return _err("Ajuste um modelo primeiro.")
-
-    import pandas as pd
-    colunas_x = estado_modelo["colunas_x"]
-    n_vars = len(colunas_x)
-
-    # Extrair valores dos inputs
-    valores_x = {}
-    for i, col in enumerate(colunas_x):
-        if i >= len(aval_inputs) or aval_inputs[i] is None:
-            return _err("Preencha todos os campos antes de calcular.")
-        valores_x[col] = float(aval_inputs[i])
-
-    # Extrair transformações do resultado do modelo
-    transformacoes_x = estado_modelo.get("transformacoes_x", {})
-    transformacao_y = estado_modelo.get("transformacao_y", "(x)")
-
-    # Obter estatísticas
-    if tabela_estatisticas is not None and isinstance(tabela_estatisticas, pd.DataFrame):
-        estatisticas_df = tabela_estatisticas
-    else:
-        return _err("Estatísticas não disponíveis.")
-
-    # Validar variáveis dicotômicas, categóricas codificadas e percentuais ANTES de avaliar
-    dicotomicas = estado_modelo.get("dicotomicas", [])
-    codigo_alocado = estado_modelo.get("codigo_alocado", [])
-    percentuais = estado_modelo.get("percentuais", [])
-
-    if "Variável" in estatisticas_df.columns:
-        est_idx = estatisticas_df.set_index("Variável")
-    else:
-        est_idx = estatisticas_df
-
-    for col in colunas_x:
-        val = valores_x[col]
-        if col in dicotomicas:
-            if val not in (0, 0.0, 1, 1.0):
-                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é dicotômica e aceita apenas valores 0 ou 1. "
-                        f"Valor informado: {val}</p>")
-        elif col in codigo_alocado and col in est_idx.index:
-            min_val = float(est_idx.loc[col, "Mínimo"])
-            max_val = float(est_idx.loc[col, "Máximo"])
-            eh_inteiro = (float(val) == int(float(val)))
-            if not eh_inteiro or val < min_val or val > max_val:
-                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é categórica codificada e aceita apenas "
-                        f"valores inteiros de {int(min_val)} a {int(max_val)}. Valor informado: {val}</p>")
-        elif col in percentuais:
-            if val < 0 or val > 1:
-                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é percentual e aceita apenas "
-                        f"valores entre 0 e 1. Valor informado: {val}</p>")
-
-    resultado = avaliar_imovel(
-        modelo_sm=estado_modelo["modelo_sm"],
-        valores_x=valores_x,
-        colunas_x=colunas_x,
-        transformacoes_x=transformacoes_x,
-        transformacao_y=transformacao_y,
-        estatisticas_df=estatisticas_df,
-        dicotomicas=dicotomicas,
-        codigo_alocado=codigo_alocado,
-        percentuais=percentuais,
-    )
-
-    if resultado is None:
-        return _err("Erro ao calcular avaliação.")
-
-    # Acumular resultado
-    nova_lista = list(estado_avaliacoes or []) + [resultado]
-    indice_base = int(indice_base_str) - 1 if indice_base_str else 0
-    html = formatar_avaliacao_html(nova_lista, indice_base=indice_base, elem_id_excluir="excluir-aval-elab")
-
-    # Atualizar choices do dropdown de base
-    choices = [str(i + 1) for i in range(len(nova_lista))]
-    # Se é a primeira avaliação, setar base como "1"
-    base_val = indice_base_str if indice_base_str else "1"
-
-    return html, nova_lista, gr.update(choices=choices, value=base_val)
-
-
-def limpar_avaliacoes_callback():
-    """Limpa o histórico de avaliações da seção 15.
-
-    CONTRACT: Retorna 3 itens (resultado_html, estado_avaliacoes, dropdown_update).
-    Se alterar, atualizar: app.py (outputs de btn_limpar_avaliacoes.click).
-    """
-    return "", [], gr.update(choices=[], value=None)
-
-
-def excluir_avaliacao_callback(indice_str, estado_avaliacoes, indice_base_str):
-    """Exclui uma avaliação da lista (seção 15).
-
-    CONTRACT: Retorna 4 itens (resultado_html, estado_avaliacoes, dropdown_update, trigger_reset).
-    """
-    if not indice_str or not indice_str.strip() or not estado_avaliacoes:
-        return gr.update(), estado_avaliacoes or [], gr.update(), ""
-
-    try:
-        idx = int(indice_str.strip()) - 1
-    except ValueError:
-        return gr.update(), estado_avaliacoes or [], gr.update(), ""
-
-    if idx < 0 or idx >= len(estado_avaliacoes):
-        return gr.update(), estado_avaliacoes or [], gr.update(), ""
-
-    nova_lista = [a for i, a in enumerate(estado_avaliacoes) if i != idx]
-
-    if not nova_lista:
-        return "", [], gr.update(choices=[], value=None), ""
-
-    # Ajustar índice base
-    base = int(indice_base_str) - 1 if indice_base_str else 0
-    if base >= len(nova_lista):
-        base = len(nova_lista) - 1
-    if base < 0:
-        base = 0
-
-    choices = [str(i + 1) for i in range(len(nova_lista))]
-    html = formatar_avaliacao_html(nova_lista, indice_base=base, elem_id_excluir="excluir-aval-elab")
-    return html, nova_lista, gr.update(choices=choices, value=str(base + 1)), ""
-
-
-def atualizar_base_avaliacao_callback(estado_avaliacoes, indice_base_str):
-    """Re-renderiza HTML quando o dropdown de base muda (seção 15).
-
-    CONTRACT: Retorna 1 item (resultado_html).
-    """
-    if not estado_avaliacoes:
-        return ""
-    indice = int(indice_base_str) - 1 if indice_base_str else 0
-    return formatar_avaliacao_html(estado_avaliacoes, indice_base=indice, elem_id_excluir="excluir-aval-elab")
-
-
-def exportar_avaliacoes_excel_callback(estado_avaliacoes):
-    """Exporta avaliações para Excel (seção 15).
-
-    CONTRACT: Retorna 1 item (download_file_update).
-    """
-    if not estado_avaliacoes:
-        return gr.update(value=None, visible=False)
-    caminho = exportar_avaliacoes_excel(estado_avaliacoes)
-    if caminho:
-        return gr.update(value=caminho, visible=True)
-    return gr.update(value=None, visible=False)
-
-
-def exportar_modelo_callback(resultado_modelo, df, df_completo, estatisticas,
-                              nome_arquivo, elaborador=None, outliers_excluidos=None):
-    """Callback para exportar modelo com download."""
-    if resultado_modelo is None:
-        return "Nenhum modelo para exportar. Ajuste o modelo primeiro.", gr.update(value=None, visible=False)
-
-    if not nome_arquivo or not nome_arquivo.strip():
-        return "Informe o nome do arquivo.", gr.update(value=None, visible=False)
-
-    caminho, msg = exportar_modelo_dai(
-        resultado_modelo, df, df_completo, estatisticas, nome_arquivo.strip(),
-        elaborador=elaborador, outliers_excluidos=outliers_excluidos or []
-    )
-
-    if caminho:
-        return msg, gr.update(value=caminho, visible=True)
-    else:
-        return msg, gr.update(value=None, visible=False)
-
-
-# ============================================================
-# CALLBACKS DE DICOTÔMICAS
-# ============================================================
-
-def atualizar_interativo_dicotomicas(colunas_x, dicotomicas, codigo_alocado, percentuais, df):
-    """Atualiza interactive dos dropdowns de transformação conforme os 3 tipos.
-
-    Dicotômicas e percentuais: transformação travada em (x).
-    Variáveis categóricas codificadas: transformação livre.
-
-    Handler para checkboxes_dicotomicas.change(), checkboxes_codigo_alocado.change(),
-    checkboxes_percentuais.change().
-
-    CONTRACT: Retorna 20 itens (transf_x_dropdowns).
-    Se alterar, atualizar: app.py (outputs dos .change dos 3 checkboxes).
-    """
-    updates = []
-    for i in range(MAX_VARS_X):
-        if i < len(colunas_x):
-            col = colunas_x[i]
-            if col in (dicotomicas or []) or col in (percentuais or []):
-                updates.append(gr.update(interactive=False, value="(x)"))
-            else:
-                updates.append(gr.update(interactive=True))
-        else:
-            updates.append(gr.update())
-    return updates
-
-
-def popular_dicotomicas_callback(estado_modelo, colunas_x, estado_df):
-    """Popula os 3 checkboxes: dicotômicas, variáveis categóricas codificadas e percentuais.
-
-    Para .dai: usa listas salvas no modelo.
-    Para CSV/Excel: auto-detecta os 3 tipos.
-
-    CONTRACT: Retorna 3 itens (checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais).
-    Se alterar, atualizar: app.py (outputs do .then de popular_dicotomicas).
-    """
-    empty = gr.update(choices=[], value=[], visible=False)
-    if not colunas_x:
-        return empty, empty, empty
-
-    choices = list(colunas_x)
-
-    if estado_modelo is not None:
-        dic = estado_modelo.get("dicotomicas", [])
-        cod = estado_modelo.get("codigo_alocado", [])
-        perc = estado_modelo.get("percentuais", [])
-    elif estado_df is not None:
-        dic = detectar_dicotomicas(estado_df, colunas_x)
-        cod = detectar_codigo_alocado(estado_df, colunas_x)
-        perc = detectar_percentuais(estado_df, colunas_x)
-    else:
-        return empty, empty, empty
-
-    return (
-        gr.update(choices=choices, value=dic, visible=True),
-        gr.update(choices=choices, value=cod, visible=True),
-        gr.update(choices=choices, value=perc, visible=True),
-    )

backend/app/core/elaboracao/outliers.py

@@ -1,300 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-outliers.py - Filtros dinâmicos, exclusão/reinclusão e iteração de outliers.
-
-Callbacks que lidam com filtros de outliers, exclusão,
-reinclusão e reinício de iteração do modelo.
-"""
-
-import gradio as gr
-
-from .formatadores import (
-    arredondar_df,
-    criar_header_secao,
-    formatar_micronumerosidade_html,
-    formatar_outliers_anteriores_html,
-)
-from .modelo import buscar_transformacoes_callback, atualizar_estatisticas_auto
-from .core import testar_micronumerosidade
-from .charts import criar_graficos_dispersao, criar_mapa
-
-
-# ============================================================
-# FILTROS
-# ============================================================
-
-def aplicar_filtros_callback(metricas_estado, n_filtros, *args):
-    """Aplica múltiplos filtros de outliers.
-
-    n_filtros: número de filtros visíveis (apenas esses serão aplicados)
-    args: var1, var2, var3, var4, op1, op2, op3, op4, val1, val2, val3, val4
-    Retorna lista de índices que satisfazem QUALQUER filtro (OR lógico).
-    """
-    if metricas_estado is None:
-        return ""
-
-    # Extrai filtros dos argumentos (apenas os filtros visíveis)
-    # Ordem: [4 vars] + [4 ops] + [4 vals]
-    filtros = []
-    for i in range(n_filtros):  # Só processa os filtros visíveis
-        var = args[i]           # vars estão nos índices 0-3
-        op = args[i + 4]        # ops estão nos índices 4-7
-        val = args[i + 8]       # vals estão nos índices 8-11
-        if var is not None and op is not None and val is not None:
-            # Converte valor para float (pode vir como string)
-            try:
-                val_float = float(val)
-            except (ValueError, TypeError):
-                continue
-            filtros.append({"variavel": var, "operador": op, "valor": val_float})
-
-    if not filtros:
-        return ""
-
-    # Aplica filtros com lógica OR
-    indices_outliers = set()
-
-    for filtro in filtros:
-        var = filtro["variavel"]
-        op = filtro["operador"]
-        val = filtro["valor"]
-
-        if var not in metricas_estado.columns:
-            continue
-
-        # Aplica operador
-        if op == "<=":
-            mask = metricas_estado[var] <= val
-        elif op == ">=":
-            mask = metricas_estado[var] >= val
-        elif op == "<":
-            mask = metricas_estado[var] < val
-        elif op == ">":
-            mask = metricas_estado[var] > val
-        elif op == "=":
-            mask = metricas_estado[var] == val
-        else:
-            continue
-
-        # Usa o índice do DataFrame (que agora são os índices originais dos dados via set_index)
-        indices_filtro = metricas_estado[mask].index.tolist()
-        indices_outliers.update(indices_filtro)
-
-    # Converte para inteiros e ordena
-    indices_ordenados = sorted([int(i) for i in indices_outliers])
-    return ", ".join(map(str, indices_ordenados))
-
-
-def adicionar_filtro_callback(n_filtros_atual):
-    """Callback para adicionar um novo filtro (mostra a próxima row oculta).
-
-    CONTRACT: Retorna 5 itens (n_filtros + 4 row updates).
-    Se alterar, atualizar: app.py (outputs de btn_adicionar_filtro.click).
-    """
-    n_novo = min(n_filtros_atual + 1, 4)
-
-    # Retorna: novo estado + 4 updates de visibilidade para rows
-    updates = [n_novo]
-    for i in range(4):
-        updates.append(gr.update(visible=(i < n_novo)))
-
-    return tuple(updates)
-
-
-def remover_ultimo_filtro_callback(n_filtros_atual):
-    """Remove o último filtro visível.
-
-    CONTRACT: Retorna 5 itens (n_filtros + 4 row updates).
-    Se alterar, atualizar: app.py (outputs de btn_remover_filtro.click).
-    """
-    n_novo = max(0, n_filtros_atual - 1)
-    return (n_novo,) + tuple(gr.update(visible=(i < n_novo)) for i in range(4))
-
-
-def limpar_filtros_callback():
-    """Limpa todos os filtros e restaura os padrões.
-
-    CONTRACT: Retorna 18 itens (n_filtros + 4 rows + 4 vars + 4 ops + 4 vals + outliers_texto).
-    Se alterar, atualizar: app.py (outputs de btn_limpar_filtros.click).
-    """
-    return (
-        2,  # estado_n_filtros (volta para 2 filtros padrão)
-        gr.update(visible=True),  # row 0
-        gr.update(visible=True),  # row 1
-        gr.update(visible=False),  # row 2
-        gr.update(visible=False),  # row 3
-        gr.update(value="Resíduo Pad."),  # var 0
-        gr.update(value="Resíduo Pad."),  # var 1
-        gr.update(value="Resíduo Pad."),  # var 2
-        gr.update(value="Resíduo Pad."),  # var 3
-        gr.update(value="<="),  # op 0
-        gr.update(value=">="),  # op 1
-        gr.update(value=">="),  # op 2
-        gr.update(value=">="),  # op 3
-        gr.update(value=-2.0),  # val 0
-        gr.update(value=2.0),  # val 1
-        gr.update(value=0.0),  # val 2
-        gr.update(value=0.0),  # val 3
-        ""  # outliers_texto
-    )
-
-
-# ============================================================
-# ITERAÇÃO DE OUTLIERS
-# ============================================================
-
-def reiniciar_iteracao_callback(df_original, outliers_anteriores, outliers_texto, reincluir_texto, iteracao_atual, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, grau_min_coef=3, grau_min_f=3):
-    """Combina outliers anteriores com novos (excluindo reincluídos), atualiza estado e reinicia análise.
-    Recalcula todas as seções (2 em diante) considerando a ausência dos outliers.
-
-    CONTRACT: Retorna 30 itens para btn_reiniciar_iteracao.click (app.py:criar_aba).
-    Se alterar, atualizar: app.py (outputs de btn_reiniciar_iteracao.click).
-    Consome buscar_transformacoes_callback por destructuring (html, resultados, _, *btns).
-    Consome atualizar_estatisticas_auto por destructuring (stats, timestamp).
-    """
-    # Parse dos novos outliers
-    novos_outliers = []
-    if outliers_texto and outliers_texto.strip():
-        try:
-            novos_outliers = [int(x.strip()) for x in outliers_texto.split(",") if x.strip()]
-        except:
-            pass
-
-    # Parse dos índices a reincluir
-    reincluir = []
-    if reincluir_texto and reincluir_texto.strip():
-        try:
-            reincluir = [int(x.strip()) for x in reincluir_texto.split(",") if x.strip()]
-        except:
-            pass
-
-    # Remove reincluídos dos anteriores, depois combina com novos (sem duplicatas)
-    anteriores_atualizados = [i for i in (outliers_anteriores or []) if i not in reincluir]
-    outliers_combinados = list(set(anteriores_atualizados + novos_outliers))
-    outliers_combinados.sort()
-
-    # Incrementa iteração
-    nova_iteracao = (iteracao_atual or 1) + 1
-
-    # Cria DataFrame filtrado
-    df_filtrado = df_original.copy()
-    if outliers_combinados:
-        df_filtrado = df_filtrado.drop(index=outliers_combinados, errors='ignore')
-
-    # Recalcula estatísticas (seção 5)
-    estatisticas, timestamp = atualizar_estatisticas_auto(df_filtrado, coluna_y, colunas_x)
-
-    # Recalcula micronumerosidade (seção 6)
-    try:
-        resultado_micro = testar_micronumerosidade(df_filtrado, list(colunas_x),
-            dicotomicas=dicotomicas, codigo_alocado=codigo_alocado)
-        html_micro = formatar_micronumerosidade_html(resultado_micro)
-    except Exception as e:
-        html_micro = f"<p style='color: red;'>Erro ao calcular micronumerosidade: {e}</p>"
-
-    # Recalcula gráficos de dispersão originais (seção 7)
-    try:
-        X = df_filtrado[list(colunas_x)]
-        y = df_filtrado[coluna_y]
-        fig_dispersao = criar_graficos_dispersao(X, y)
-    except Exception as e:
-        print(f"Erro ao gerar gráficos de dispersão: {e}")
-        fig_dispersao = None
-
-    # Recalcula busca de transformações (seção 8)
-    try:
-        busca_html_result, resultados_busca, _, *btn_updates = buscar_transformacoes_callback(
-            df_filtrado, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, int(grau_min_coef), int(grau_min_f)
-        )
-    except Exception as e:
-        busca_html_result = f"<p style='color: red;'>Erro na busca: {e}</p>"
-        resultados_busca = []
-        btn_updates = [gr.update(visible=False) for _ in range(5)]
-
-    # Radio buttons coerentes com os novos resultados
-    if resultados_busca:
-        grau_coef_min = min(
-            min(r.get("graus_coef", {}).values(), default=0)
-            for r in resultados_busca
-        )
-        grau_f_min = min(r.get("grau_f", 0) for r in resultados_busca)
-    else:
-        grau_coef_min = int(grau_min_coef)
-        grau_f_min = int(grau_min_f)
-
-    # Atualiza textos
-    html_outliers_ant = formatar_outliers_anteriores_html(
-        len(outliers_combinados),
-        ", ".join(map(str, outliers_combinados)) if outliers_combinados else ""
-    )
-
-    # Visibilidade do accordion
-    accordion_visivel = len(outliers_combinados) > 0
-
-    # Mapa atualizado
-    mapa_html = criar_mapa(df_filtrado)
-
-    # Header updates com timestamp
-    header_2_update = gr.update(value=criar_header_secao(2, "Visualizar Dados", timestamp))
-    header_5_update = gr.update(value=criar_header_secao(5, "Estatísticas das Variáveis Selecionadas", timestamp))
-    header_6_update = gr.update(value=criar_header_secao(6, "Teste de Micronumerosidade (NBR 14.653-2)", timestamp))
-    header_7_update = gr.update(value=criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes", timestamp))
-    header_8_update = gr.update(value=criar_header_secao(8, "Transformações Sugeridas", timestamp))
-
-    return (
-        outliers_combinados,      # estado_outliers_anteriores
-        nova_iteracao,            # estado_iteracao
-        df_filtrado,              # estado_df_filtrado
-        arredondar_df(df_filtrado),     # tabela_dados
-        estatisticas,             # tabela_estatisticas
-        header_5_update,          # header_secao_5
-        html_outliers_ant,        # html_outliers_anteriores
-        html_outliers_ant,        # html_outliers_sec14
-        gr.update(visible=accordion_visivel),  # accordion_outliers_anteriores
-        "",                       # outliers_texto (limpo)
-        "",                       # reincluir_texto (limpo)
-        None,                     # tabela_metricas (limpa)
-        None,                     # estado_metricas (limpo)
-        gr.update(value=criar_header_secao(13, "Analisar Outliers")),  # header_secao_13
-        f"Excluídos: {len(outliers_combinados)} | A excluir: 0 | A reincluir: 0 | Total: {len(outliers_combinados)}",  # txt_resumo_outliers
-        mapa_html,                # mapa_html atualizado
-        # Novos outputs para seções 2, 6, 7, 8
-        header_2_update,          # header_secao_2
-        html_micro,               # html_micronumerosidade
-        header_6_update,          # header_secao_6
-        fig_dispersao,            # plot_dispersao
-        header_7_update,          # header_secao_7
-        busca_html_result,        # busca_html
-        resultados_busca,         # estado_resultados_busca
-        header_8_update,          # header_secao_8
-        *btn_updates,             # botões adotar (5 botões)
-        gr.update(value=grau_coef_min),  # slider_grau_coef
-        gr.update(value=grau_f_min),     # slider_grau_f
-    )
-
-
-def atualizar_resumo_outliers(outliers_anteriores, outliers_texto, reincluir_texto):
-    """Atualiza o resumo de outliers quando o usuário edita os campos."""
-    n_anteriores = len(outliers_anteriores) if outliers_anteriores else 0
-
-    novos_outliers = []
-    if outliers_texto and outliers_texto.strip():
-        try:
-            novos_outliers = [int(x.strip()) for x in outliers_texto.split(",") if x.strip()]
-        except:
-            pass
-
-    reincluir = []
-    if reincluir_texto and reincluir_texto.strip():
-        try:
-            reincluir = [int(x.strip()) for x in reincluir_texto.split(",") if x.strip()]
-        except:
-            pass
-
-    n_novos = len(novos_outliers)
-    n_reincluir = len(reincluir)
-    # Calcula total: anteriores menos reincluídos, mais novos
-    anteriores_atualizados = [i for i in (outliers_anteriores or []) if i not in reincluir]
-    n_total = len(set(anteriores_atualizados + novos_outliers))
-
-    return f"Excluídos: {n_anteriores} | A excluir: {n_novos} | A reincluir: {n_reincluir} | Total: {n_total}"

backend/app/core/visualizacao/app.py

@@ -1,46 +1,20 @@
 from __future__ import annotations
 
-# ============================================================
-# IMPORTAÇÕES
-# ============================================================
-import pandas as pd
-import numpy as np
-import folium
-from folium import plugins
-from joblib import load
-import os
+import math
 import re
 import traceback
 from datetime import datetime
 from html import escape
 
-from app.runtime_config import resolve_core_path
-
-try:
-    import gradio as gr
-except Exception:  # pragma: no cover - runtime portatil nao precisa da UI gradio
-    class _GradioPlaceholder:
-        class SelectData:
-            pass
-
-        @staticmethod
-        def update(*args, **kwargs):
-            raise RuntimeError("Gradio indisponivel neste runtime")
-
-        def __getattr__(self, name: str):
-            raise RuntimeError(f"Gradio indisponivel neste runtime: {name}")
-
-    gr = _GradioPlaceholder()
-
-# Importações para gráficos (trazidas de graficos.py)
-from scipy import stats
+import branca.colormap as cm
+import folium
+import numpy as np
+import pandas as pd
 import plotly.graph_objects as go
+from folium import plugins
+from scipy import stats
 from statsmodels.stats.outliers_influence import OLSInfluence
-import branca.colormap as cm
-import math
 
-from app.core.elaboracao.core import avaliar_imovel, _migrar_pacote_v1_para_v2, exportar_avaliacoes_excel
-from app.core.elaboracao.formatadores import formatar_avaliacao_html
 from app.core.map_layers import (
     add_bairros_layer,
     add_indice_marker,
@@ -49,430 +23,297 @@ from app.core.map_layers import (
     add_zoom_responsive_circle_markers,
 )
 
-# ============================================================
-# CONSTANTES
-# ============================================================
-CHAVES_ESPERADAS = ["versao", "dados", "transformacoes", "modelo"]
-
-# Constantes para avaliação
-MAX_VARS_AVAL = 20
-N_COLS_AVAL = 2
-N_ROWS_AVAL = MAX_VARS_AVAL // N_COLS_AVAL  # 10
-
-# Cores consistentes (trazidas de graficos.py)
-COR_PRINCIPAL = '#FF8C00'  # Laranja
-COR_LINHA = '#dc3545'  # Vermelho para linhas de referência
-
-# ============================================================
-# FUNÇÃO: CARREGAR CSS EXTERNO
-# ============================================================
-def carregar_css():
-    """Carrega o arquivo CSS externo."""
-    css_path = resolve_core_path("visualizacao", "styles.css")
-    try:
-        with open(css_path, "r", encoding="utf-8") as f:
-            return f.read()
-    except FileNotFoundError:
-        print(f"Aviso: Arquivo CSS não encontrado em {css_path}")
-        return ""
 
-# ============================================================
-# LÓGICA DE GERAÇÃO DE GRÁFICOS (ADAPTADA DE GRAFICOS.PY)
-# ============================================================
+COR_PRINCIPAL = "#FF8C00"
+COR_LINHA = "#dc3545"
+
 
 def _criar_grafico_obs_calc(y_obs, y_calc, indices=None):
-    """Cria gráfico de valores observados vs calculados (Plotly Figure)."""
     try:
         fig = go.Figure()
-
         scatter_args = dict(
             x=y_calc,
             y=y_obs,
-            mode='markers',
-            marker=dict(
-                color=COR_PRINCIPAL,
-                size=10,
-                line=dict(color='black', width=1)
-            ),
-            name='Dados',
+            mode="markers",
+            marker=dict(color=COR_PRINCIPAL, size=10, line=dict(color="black", width=1)),
+            name="Dados",
         )
         if indices is not None:
-            scatter_args['customdata'] = indices
-            scatter_args['hovertemplate'] = "<b>Índice:</b> %{customdata}<br><b>Calculado:</b> %{x:.2f}<br><b>Observado:</b> %{y:.2f}<extra></extra>"
+            scatter_args["customdata"] = indices
+            scatter_args["hovertemplate"] = (
+                "<b>Índice:</b> %{customdata}<br><b>Calculado:</b> %{x:.2f}<br>"
+                "<b>Observado:</b> %{y:.2f}<extra></extra>"
+            )
         else:
-            scatter_args['hovertemplate'] = "<b>Calculado:</b> %{x:.2f}<br><b>Observado:</b> %{y:.2f}<extra></extra>"
+            scatter_args["hovertemplate"] = (
+                "<b>Calculado:</b> %{x:.2f}<br><b>Observado:</b> %{y:.2f}<extra></extra>"
+            )
 
-        # Scatter plot
         fig.add_trace(go.Scatter(**scatter_args))
 
-        # Linha de identidade (45 graus)
         min_val = min(min(y_obs), min(y_calc))
         max_val = max(max(y_obs), max(y_calc))
         margin = (max_val - min_val) * 0.05
 
-        fig.add_trace(go.Scatter(
-            x=[min_val - margin, max_val + margin],
-            y=[min_val - margin, max_val + margin],
-            mode='lines',
-            line=dict(color=COR_LINHA, dash='dash', width=2),
-            name='Linha de identidade'
-        ))
+        fig.add_trace(
+            go.Scatter(
+                x=[min_val - margin, max_val + margin],
+                y=[min_val - margin, max_val + margin],
+                mode="lines",
+                line=dict(color=COR_LINHA, dash="dash", width=2),
+                name="Linha de identidade",
+            )
+        )
 
         fig.update_layout(
-            title=dict(text='Valores Observados vs Calculados', x=0.5),
-            xaxis_title='Valores Calculados',
-            yaxis_title='Valores Observados',
+            title=dict(text="Valores Observados vs Calculados", x=0.5),
+            xaxis_title="Valores Calculados",
+            yaxis_title="Valores Observados",
             showlegend=True,
-            plot_bgcolor='white',
-            margin=dict(l=60, r=40, t=60, b=60)
+            plot_bgcolor="white",
+            margin=dict(l=60, r=40, t=60, b=60),
         )
-
-        fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
-        fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
-
+        fig.update_xaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
+        fig.update_yaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
         return fig
-    except Exception as e:
-        print(f"Erro ao criar gráfico obs vs calc: {e}")
+    except Exception as exc:
+        print(f"Erro ao criar gráfico obs vs calc: {exc}")
         return None
 
+
 def _criar_grafico_residuos(y_calc, residuos, indices=None):
-    """Cria gráfico de resíduos vs valores ajustados (Plotly Figure)."""
     try:
         fig = go.Figure()
-
         scatter_args = dict(
             x=y_calc,
             y=residuos,
-            mode='markers',
-            marker=dict(
-                color=COR_PRINCIPAL,
-                size=10,
-                line=dict(color='black', width=1)
-            ),
-            name='Resíduos',
+            mode="markers",
+            marker=dict(color=COR_PRINCIPAL, size=10, line=dict(color="black", width=1)),
+            name="Resíduos",
         )
         if indices is not None:
-            scatter_args['customdata'] = indices
-            scatter_args['hovertemplate'] = "<b>Índice:</b> %{customdata}<br><b>Ajustado:</b> %{x:.2f}<br><b>Resíduo:</b> %{y:.4f}<extra></extra>"
+            scatter_args["customdata"] = indices
+            scatter_args["hovertemplate"] = (
+                "<b>Índice:</b> %{customdata}<br><b>Ajustado:</b> %{x:.2f}<br>"
+                "<b>Resíduo:</b> %{y:.4f}<extra></extra>"
+            )
         else:
-            scatter_args['hovertemplate'] = "<b>Ajustado:</b> %{x:.2f}<br><b>Resíduo:</b> %{y:.4f}<extra></extra>"
+            scatter_args["hovertemplate"] = (
+                "<b>Ajustado:</b> %{x:.2f}<br><b>Resíduo:</b> %{y:.4f}<extra></extra>"
+            )
 
         fig.add_trace(go.Scatter(**scatter_args))
-
         fig.add_hline(y=0, line_dash="dash", line_color=COR_LINHA, line_width=2)
-
         fig.update_layout(
-            title=dict(text='Resíduos vs Valores Ajustados', x=0.5),
-            xaxis_title='Valores Ajustados',
-            yaxis_title='Resíduos',
+            title=dict(text="Resíduos vs Valores Ajustados", x=0.5),
+            xaxis_title="Valores Ajustados",
+            yaxis_title="Resíduos",
             showlegend=False,
-            plot_bgcolor='white',
-            margin=dict(l=60, r=40, t=60, b=60)
+            plot_bgcolor="white",
+            margin=dict(l=60, r=40, t=60, b=60),
         )
-
-        fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
-        fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
-
+        fig.update_xaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
+        fig.update_yaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
         return fig
-    except Exception as e:
-        print(f"Erro ao criar gráfico de resíduos: {e}")
+    except Exception as exc:
+        print(f"Erro ao criar gráfico de resíduos: {exc}")
         return None
 
+
 def _criar_histograma_residuos(residuos):
-    """Cria histograma dos resíduos com curva normal (Plotly Figure)."""
     try:
         fig = go.Figure()
-
-        fig.add_trace(go.Histogram(
-            x=residuos,
-            histnorm='probability density',
-            marker=dict(color=COR_PRINCIPAL, line=dict(color='black', width=1)),
-            opacity=0.7,
-            name='Resíduos'
-        ))
+        fig.add_trace(
+            go.Histogram(
+                x=residuos,
+                histnorm="probability density",
+                marker=dict(color=COR_PRINCIPAL, line=dict(color="black", width=1)),
+                opacity=0.7,
+                name="Resíduos",
+            )
+        )
 
         mu, sigma = np.mean(residuos), np.std(residuos)
         x_norm = np.linspace(min(residuos) - sigma, max(residuos) + sigma, 100)
         y_norm = stats.norm.pdf(x_norm, mu, sigma)
-
-        fig.add_trace(go.Scatter(
-            x=x_norm,
-            y=y_norm,
-            mode='lines',
-            line=dict(color=COR_LINHA, width=3),
-            name='Curva Normal'
-        ))
+        fig.add_trace(
+            go.Scatter(
+                x=x_norm,
+                y=y_norm,
+                mode="lines",
+                line=dict(color=COR_LINHA, width=3),
+                name="Curva Normal",
+            )
+        )
 
         fig.update_layout(
-            title=dict(text='Distribuição dos Resíduos', x=0.5),
-            xaxis_title='Resíduos',
-            yaxis_title='Densidade',
+            title=dict(text="Distribuição dos Resíduos", x=0.5),
+            xaxis_title="Resíduos",
+            yaxis_title="Densidade",
             showlegend=True,
-            plot_bgcolor='white',
-            barmode='overlay',
-            margin=dict(l=60, r=40, t=60, b=60)
+            plot_bgcolor="white",
+            barmode="overlay",
+            margin=dict(l=60, r=40, t=60, b=60),
         )
-
-        fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
-        fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
-
+        fig.update_xaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
+        fig.update_yaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
         return fig
-    except Exception as e:
-        print(f"Erro ao criar histograma: {e}")
+    except Exception as exc:
+        print(f"Erro ao criar histograma: {exc}")
         return None
 
 
 def _criar_grafico_cook(modelos_sm):
-    """Cria gráfico de Distância de Cook (Plotly Figure)."""
     try:
-        if modelos_sm is None: return None
+        if modelos_sm is None:
+            return None
 
         influence = OLSInfluence(modelos_sm)
         cooks_d = influence.cooks_distance[0]
-
         n = len(cooks_d)
         indices = np.arange(1, n + 1)
         limite = 4 / n
 
         fig = go.Figure()
-
-        # Hastes (linhas verticais)
         for idx, valor in zip(indices, cooks_d):
             cor = COR_LINHA if valor > limite else COR_PRINCIPAL
             fig.add_trace(
-                go.Scatter(x=[idx, idx],
-                           y=[0, valor],
-                           mode='lines',
-                           line=dict(color=cor, width=1.5),
-                           showlegend=False,
-                           hoverinfo='skip'))
-
-        # Pontos
-        cores_pontos = [
-            COR_LINHA if v > limite else COR_PRINCIPAL for v in cooks_d
-        ]
+                go.Scatter(
+                    x=[idx, idx],
+                    y=[0, valor],
+                    mode="lines",
+                    line=dict(color=cor, width=1.5),
+                    showlegend=False,
+                    hoverinfo="skip",
+                )
+            )
+
+        cores_pontos = [COR_LINHA if v > limite else COR_PRINCIPAL for v in cooks_d]
         fig.add_trace(
             go.Scatter(
                 x=indices,
                 y=cooks_d,
-                mode='markers',
-                marker=dict(color=cores_pontos,
-                            size=8,
-                            line=dict(color='black', width=1)),
-                name='Distância de Cook',
-                hovertemplate='Obs: %{x}<br>Cook: %{y:.4f}<extra></extra>'))
-
-        fig.add_hline(y=limite,
-                      line_dash="dash",
-                      line_color='gray',
-                      annotation_text=f"4/n = {limite:.4f}",
-                      annotation_position="top right")
-
-        fig.update_layout(title=dict(text='Distância de Cook', x=0.5),
-                          xaxis_title='Observação',
-                          yaxis_title='Distância de Cook',
-                          plot_bgcolor='white',
-                          margin=dict(l=60, r=40, t=60, b=60))
-
-        fig.update_xaxes(showgrid=True,
-                         gridcolor='lightgray',
-                         showline=True,
-                         linecolor='black')
-        fig.update_yaxes(showgrid=True,
-                         gridcolor='lightgray',
-                         showline=True,
-                         linecolor='black')
-
+                mode="markers",
+                marker=dict(color=cores_pontos, size=8, line=dict(color="black", width=1)),
+                name="Distância de Cook",
+                hovertemplate="Obs: %{x}<br>Cook: %{y:.4f}<extra></extra>",
+            )
+        )
+        fig.add_hline(
+            y=limite,
+            line_dash="dash",
+            line_color="gray",
+            annotation_text=f"4/n = {limite:.4f}",
+            annotation_position="top right",
+        )
+        fig.update_layout(
+            title=dict(text="Distância de Cook", x=0.5),
+            xaxis_title="Observação",
+            yaxis_title="Distância de Cook",
+            plot_bgcolor="white",
+            margin=dict(l=60, r=40, t=60, b=60),
+        )
+        fig.update_xaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
+        fig.update_yaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
         return fig
-    except Exception as e:
-        print(f"Erro ao criar gráfico de Cook: {e}")
+    except Exception as exc:
+        print(f"Erro ao criar gráfico de Cook: {exc}")
         return None
 
+
 def _criar_grafico_correlacao(modelos_sm, nome_y: str | None = None):
-    """Gera heatmap de correlação com cores customizadas e diagonal limpa."""
     try:
-        if modelos_sm is None or not hasattr(modelos_sm, 'model'):
+        if modelos_sm is None or not hasattr(modelos_sm, "model"):
             return None
 
         model = modelos_sm.model
         X = model.exog
         X_names = model.exog_names
         y = model.endog
-        y_name_base = str(nome_y or "").strip() or str(getattr(model, 'endog_names', 'Variável Dependente') or '').strip() or 'Variável Dependente'
+        y_name_base = (
+            str(nome_y or "").strip()
+            or str(getattr(model, "endog_names", "Variável Dependente") or "").strip()
+            or "Variável Dependente"
+        )
         y_name = y_name_base if re.search(r"\(Y\)$", y_name_base, flags=re.IGNORECASE) else f"{y_name_base} (Y)"
 
         df_X = pd.DataFrame(X, columns=X_names)
         df_X = df_X.drop(
-            columns=[c for c in df_X.columns if str(c).lower() in ('const', 'intercept')],
-            errors='ignore'
+            columns=[c for c in df_X.columns if str(c).lower() in ("const", "intercept")],
+            errors="ignore",
         )
 
         df_y = pd.DataFrame({y_name: y})
-        df = pd.concat([df_y, df_X], axis=1)
-
-        # garantir numérico
-        df = df.apply(pd.to_numeric, errors='coerce')
-
-        # remover colunas constantes
+        df = pd.concat([df_y, df_X], axis=1).apply(pd.to_numeric, errors="coerce")
         variancias = df.var(ddof=0)
         df = df.loc[:, variancias.fillna(0) > 0]
-
         if df.shape[1] < 2:
             return None
 
-        # ✅ CRIAR corr
         corr = df.corr()
-
         if corr.isnull().values.all():
             return None
 
-        # ✅ remover diagonal (SEM numpy in-place)
         mask = np.eye(len(corr), dtype=bool)
         corr = corr.where(~mask)
-
-        # texto
-        text = np.where(
-            np.isnan(corr.values),
-            "",
-            np.round(corr.values, 2).astype(str)
+        text = np.where(np.isnan(corr.values), "", np.round(corr.values, 2).astype(str))
+
+        fig = go.Figure(
+            go.Heatmap(
+                z=corr.values,
+                x=corr.columns,
+                y=corr.index,
+                text=text,
+                texttemplate="%{text}",
+                textfont=dict(size=10),
+                zmin=-1,
+                zmax=1,
+                zmid=0,
+                colorscale=[
+                    [0.00, "rgb(103,0,31)"],
+                    [0.08, "rgb(178,24,43)"],
+                    [0.16, "rgb(214,96,77)"],
+                    [0.24, "rgb(244,165,130)"],
+                    [0.32, "rgb(253,219,199)"],
+                    [0.45, "rgb(255,255,255)"],
+                    [0.55, "rgb(255,255,255)"],
+                    [0.68, "rgb(209,229,240)"],
+                    [0.76, "rgb(146,197,222)"],
+                    [0.84, "rgb(67,147,195)"],
+                    [0.92, "rgb(33,102,172)"],
+                    [1.00, "rgb(5,48,97)"],
+                ],
+                colorbar=dict(title="Correlação"),
+                hovertemplate="%{x} × %{y}<br>ρ = %{z:.3f}<extra></extra>",
+            )
         )
-
-        fig = go.Figure(go.Heatmap(
-            z=corr.values,
-            x=corr.columns,
-            y=corr.index,
-            text=text,
-            texttemplate="%{text}",
-            textfont=dict(size=10),
-            zmin=-1,
-            zmax=1,
-            zmid=0,
-            colorscale = [
-                [0.00, "rgb(103,0,31)"],
-                [0.08, "rgb(178,24,43)"],
-                [0.16, "rgb(214,96,77)"],
-                [0.24, "rgb(244,165,130)"],
-                [0.32, "rgb(253,219,199)"],
-
-                # faixa branca larga (inalterada)
-                [0.45, "rgb(255,255,255)"],
-                [0.55, "rgb(255,255,255)"],
-
-                [0.68, "rgb(209,229,240)"],
-                [0.76, "rgb(146,197,222)"],
-                [0.84, "rgb(67,147,195)"],
-                [0.92, "rgb(33,102,172)"],
-                [1.00, "rgb(5,48,97)"]
-            ],
-            colorbar=dict(title='Correlação'),
-            hovertemplate="%{x} × %{y}<br>ρ = %{z:.3f}<extra></extra>"
-        ))
-
-        # ✅ diagonal VISUAL (robusta)
         fig.add_shape(
             type="line",
             xref="paper",
             yref="paper",
-            x0=0, y0=1,
-            x1=1, y1=0,
+            x0=0,
+            y0=1,
+            x1=1,
+            y1=0,
             line=dict(color="rgba(0,0,0,0.35)", width=1),
-            layer="above"
+            layer="above",
         )
-
         fig.update_layout(
             title=dict(text="Matriz de Correlação", x=0.5),
             height=600,
-            template='plotly_white',
+            template="plotly_white",
             xaxis=dict(tickangle=45, showgrid=False),
-            yaxis=dict(autorange='reversed', showgrid=False)
+            yaxis=dict(autorange="reversed", showgrid=False),
         )
-
         return fig
-
-    except Exception as e:
-        print(f"Erro na geração do gráfico: {e}")
+    except Exception as exc:
+        print(f"Erro na geração do gráfico: {exc}")
         traceback.print_exc()
         return None
 
-# def _criar_grafico_correlacao(modelos_sm):
-#     """Gera heatmap de correlação (Plotly Figure)."""
-#     try:
-#         if modelos_sm is None or not hasattr(modelos_sm, 'model'):
-#             return None
-
-#         model = modelos_sm.model
-#         if not hasattr(model, 'exog') or not hasattr(model, 'endog'):
-#             return None
-
-#         X = model.exog
-#         X_names = model.exog_names
-#         y = model.endog
-#         y_name = getattr(model, 'endog_names', 'Variável Dependente')
-
-#         df_X = pd.DataFrame(X, columns=X_names)
-
-#         # Remover constantes explícitas
-#         df_X = df_X.drop(
-#             columns=[c for c in df_X.columns if c.lower() in ('const', 'intercept')],
-#             errors='ignore'
-#         )
-
-#         df_y = pd.DataFrame({y_name: y})
-#         df = pd.concat([df_y, df_X], axis=1)
-
-#         # Remover colunas constantes
-#         variancias = df.var(ddof=0)
-#         df = df.loc[:, variancias.fillna(0) > 0]
-
-#         if df.shape[1] < 2: return None
-
-#         corr = df.corr()
-#         if corr.isnull().values.all(): return None
-
-#         text = np.round(corr.values, 2).astype(str)
-
-#         fig = go.Figure(data=go.Heatmap(
-#             z=corr.values,
-#             x=corr.columns,
-#             y=corr.index,
-#             text=text,
-#             texttemplate="%{text}",
-#             textfont=dict(size=10),
-#             zmin=-1, zmax=1,
-#             colorscale = [
-#                 [0.0,  "rgb(178,24,43)"],   # red
-#                 [0.35, "rgb(178,24,43)"],
-
-#                 [0.45, "rgb(255,255,255)"], # start white
-#                 [0.55, "rgb(255,255,255)"], # end white
-
-#                 [0.65, "rgb(33,102,172)"],
-#                 [1.0,  "rgb(33,102,172)"]   # blue
-#             ],
-#             colorbar=dict(title='Correlação')
-#         ))
-
-#         fig.update_layout(
-#             title=dict(text="Matriz de Correlação", x=0.5),
-#             height=600,
-#             template='plotly_white',
-#             xaxis=dict(tickangle=45, showgrid=False),
-#             yaxis=dict(autorange='reversed', showgrid=True)
-#         )
-
-#         return fig
-#     except Exception:
-#         return None
 
 def gerar_todos_graficos(pacote):
-    """Orquestra a geração de todos os gráficos a partir do pacote."""
-    graficos = {
-        "obs_calc": None,
-        "residuos": None,
-        "hist": None,
-        "cook": None,
-        "corr": None
-    }
+    graficos = {"obs_calc": None, "residuos": None, "hist": None, "cook": None, "corr": None}
 
     obs_calc = pacote["modelo"]["obs_calc"]
     modelos_sm = pacote["modelo"]["sm"]
@@ -483,81 +324,60 @@ def gerar_todos_graficos(pacote):
         if primeira_linha:
             nome_y = primeira_linha.split(": ", 1)[0].strip() or None
 
-    # Identificar vetores
     y_obs = None
     y_calc = None
     residuos = None
     indices = None
 
-    # Tenta pegar do DataFrame obs_calc
     if obs_calc is not None and not obs_calc.empty:
         cols_lower = {str(c).lower(): c for c in obs_calc.columns}
-
-        # Extrair índices do DataFrame
         indices = obs_calc.index.values if obs_calc.index is not None else None
 
-        # Encontrar coluna observada
-        for nome in ['observado', 'obs', 'y_obs', 'y', 'valor_observado']:
+        for nome in ["observado", "obs", "y_obs", "y", "valor_observado"]:
             if nome in cols_lower:
                 y_obs = obs_calc[cols_lower[nome]].values
                 break
-
-        # Encontrar coluna calculada
-        for nome in ['calculado', 'calc', 'y_calc', 'y_hat', 'previsto']:
+        for nome in ["calculado", "calc", "y_calc", "y_hat", "previsto"]:
             if nome in cols_lower:
                 y_calc = obs_calc[cols_lower[nome]].values
                 break
-
-        # Encontrar coluna resíduos
-        for nome in ['residuo', 'residuos', 'resid']:
+        for nome in ["residuo", "residuos", "resid"]:
             if nome in cols_lower:
                 residuos = obs_calc[cols_lower[nome]].values
                 break
 
-    # Fallback para o objeto statsmodels
     if modelos_sm is not None:
         try:
-            if y_obs is None and hasattr(modelos_sm.model, 'endog'):
+            if y_obs is None and hasattr(modelos_sm.model, "endog"):
                 y_obs = modelos_sm.model.endog
-            if y_calc is None and hasattr(modelos_sm, 'fittedvalues'):
+            if y_calc is None and hasattr(modelos_sm, "fittedvalues"):
                 y_calc = modelos_sm.fittedvalues
-            if residuos is None and hasattr(modelos_sm, 'resid'):
+            if residuos is None and hasattr(modelos_sm, "resid"):
                 residuos = modelos_sm.resid
         except Exception:
             pass
 
-    # Cálculo manual se necessário
     if residuos is None and y_obs is not None and y_calc is not None:
         residuos = np.array(y_obs) - np.array(y_calc)
 
-    # Converter para numpy
     y_obs = np.array(y_obs) if y_obs is not None else None
     y_calc = np.array(y_calc) if y_calc is not None else None
     residuos = np.array(residuos) if residuos is not None else None
 
-    # Gerar cada gráfico
     if y_obs is not None and y_calc is not None:
         graficos["obs_calc"] = _criar_grafico_obs_calc(y_obs, y_calc, indices)
-
     if residuos is not None and y_calc is not None:
         graficos["residuos"] = _criar_grafico_residuos(y_calc, residuos, indices)
-
     if residuos is not None:
         graficos["hist"] = _criar_histograma_residuos(residuos)
-
     if modelos_sm is not None:
         graficos["cook"] = _criar_grafico_cook(modelos_sm)
         graficos["corr"] = _criar_grafico_correlacao(modelos_sm, nome_y=nome_y)
 
     return graficos
 
-# ============================================================
-# FUNÇÃO: REORGANIZAR DIAGNOSTICOS PARA EXIBIÇÃO
-# ============================================================
+
 def reorganizar_modelos_resumos(diagnosticos):
-    """
-    Converte diagnosticos v2 (já agrupado) para formato de exibição HTML.
-    """
     gerais = diagnosticos.get("gerais", {})
     return {
         "estatisticas_gerais": {
@@ -567,19 +387,19 @@ def reorganizar_modelos_resumos(diagnosticos):
             "mse": {"nome": "MSE", "valor": gerais.get("mse")},
             "r2": {"nome": "R²", "valor": gerais.get("r2")},
             "r2_ajustado": {"nome": "R² ajustado", "valor": gerais.get("r2_ajustado")},
-            "r_pearson": {"nome": "Correlação Pearson", "valor": gerais.get("r_pearson")}
+            "r_pearson": {"nome": "Correlação Pearson", "valor": gerais.get("r_pearson")},
         },
         "teste_f": {
             "nome": "Teste F",
             "estatistica": diagnosticos.get("teste_f", {}).get("estatistica"),
             "pvalor": diagnosticos.get("teste_f", {}).get("p_valor"),
-            "interpretacao": diagnosticos.get("teste_f", {}).get("interpretacao")
+            "interpretacao": diagnosticos.get("teste_f", {}).get("interpretacao"),
         },
         "teste_ks": {
             "nome": "Teste de Normalidade (Kolmogorov-Smirnov)",
             "estatistica": diagnosticos.get("teste_ks", {}).get("estatistica"),
             "pvalor": diagnosticos.get("teste_ks", {}).get("p_valor"),
-            "interpretacao": diagnosticos.get("teste_ks", {}).get("interpretacao")
+            "interpretacao": diagnosticos.get("teste_ks", {}).get("interpretacao"),
         },
         "perc_resid": {
             "nome": "Teste de Normalidade (Comparação com a Curva Normal)",
@@ -587,59 +407,54 @@ def reorganizar_modelos_resumos(diagnosticos):
             "interpretacao": [
                 "Ideal 68% → aceitável entre 64% e 75%",
                 "Ideal 90% → aceitável entre 88% e 95%",
-                "Ideal 95% → aceitável entre 95% e 100%"
-            ]
+                "Ideal 95% → aceitável entre 95% e 100%",
+            ],
         },
         "teste_dw": {
             "nome": "Teste de Autocorrelação (Durbin-Watson)",
             "estatistica": diagnosticos.get("teste_dw", {}).get("estatistica"),
-            "interpretacao": diagnosticos.get("teste_dw", {}).get("interpretacao")
+            "interpretacao": diagnosticos.get("teste_dw", {}).get("interpretacao"),
         },
         "teste_bp": {
             "nome": "Teste de Homocedasticidade (Breusch-Pagan)",
             "estatistica": diagnosticos.get("teste_bp", {}).get("estatistica"),
             "pvalor": diagnosticos.get("teste_bp", {}).get("p_valor"),
-            "interpretacao": diagnosticos.get("teste_bp", {}).get("interpretacao")
+            "interpretacao": diagnosticos.get("teste_bp", {}).get("interpretacao"),
         },
-        "equacao": diagnosticos.get("equacao")
+        "equacao": diagnosticos.get("equacao"),
     }
 
-# ============================================================
-# FUNÇÃO: FORMATAR VALOR MONETÁRIO
-# ============================================================
+
 def formatar_monetario(valor):
-    if pd.isna(valor): return "N/A"
+    if pd.isna(valor):
+        return "N/A"
     return f"R$ {valor:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
 
-# ============================================================
-# FUNÇÃO: FORMATAR RESUMO COMO HTML
-# ============================================================
-def formatar_resumo_html(resumo_reorganizado):
 
+def formatar_resumo_html(resumo_reorganizado):
     def criar_titulo_secao(titulo):
         return f'<div class="section-title-orange-solid">{titulo}</div>'
 
     def criar_linha_campo(campo, valor):
-        return f"""<div class="field-row"><span class="field-row-label">{campo}</span><span class="field-row-value">{valor}</span></div>"""
+        return f'<div class="field-row"><span class="field-row-label">{campo}</span><span class="field-row-value">{valor}</span></div>'
 
     def criar_linha_interpretacao(interpretacao):
-        return f"""<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value-italic">{interpretacao}</span></div>"""
+        return f'<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value-italic">{interpretacao}</span></div>'
 
     def formatar_numero(valor, casas_decimais=4):
-        if valor is None: return "N/A"
-        if isinstance(valor, (int, float, np.floating)): return f"{valor:.{casas_decimais}f}"
+        if valor is None:
+            return "N/A"
+        if isinstance(valor, (int, float, np.floating)):
+            return f"{valor:.{casas_decimais}f}"
         return str(valor)
 
     linhas_html = []
-
-    # 1. Estatísticas Gerais
     estat_gerais = resumo_reorganizado.get("estatisticas_gerais", {})
     if estat_gerais:
         linhas_html.append(criar_titulo_secao("Estatísticas Gerais"))
         for chave, dados in estat_gerais.items():
             linhas_html.append(criar_linha_campo(dados.get("nome", chave), formatar_numero(dados.get("valor"))))
 
-    # 2. Testes (ordem: F, KS, Curva Normal, DW, BP)
     for chave_teste, label in [("teste_f", "Estatística F"), ("teste_ks", "Estatística KS")]:
         teste = resumo_reorganizado.get(chave_teste, {})
         if teste.get("estatistica") is not None:
@@ -650,7 +465,6 @@ def formatar_resumo_html(resumo_reorganizado):
             if teste.get("interpretacao"):
                 linhas_html.append(criar_linha_interpretacao(teste["interpretacao"]))
 
-    # Percentuais (Comparação com a Curva Normal — logo após KS)
     perc_resid = resumo_reorganizado.get("perc_resid", {})
     if perc_resid.get("valor") is not None:
         linhas_html.append(criar_titulo_secao(perc_resid.get("nome")))
@@ -670,24 +484,24 @@ def formatar_resumo_html(resumo_reorganizado):
             if teste.get("interpretacao"):
                 linhas_html.append(criar_linha_interpretacao(teste["interpretacao"]))
 
-    return f"""<div class="dai-card scrollable-container">{"".join(linhas_html)}</div>"""
+    return f'<div class="dai-card scrollable-container">{"".join(linhas_html)}</div>'
+
 
-# ============================================================
-# FUNÇÃO: CRIAR TÍTULO DE SEÇÃO ESTILIZADO
-# ============================================================
 def criar_titulo_secao_html(titulo):
     return f'<div class="section-title-orange">{titulo}</div>'
 
-# ============================================================
-# FUNÇÃO: FORMATAR ESCALAS/TRANSFORMAÇÕES
-# ============================================================
+
 def formatar_escalas_html(escalas_raw):
-    if isinstance(escalas_raw, pd.DataFrame): itens = escalas_raw.iloc[:, 0].tolist()
-    elif isinstance(escalas_raw, list): itens = escalas_raw
-    else: itens = [str(escalas_raw)]
+    if isinstance(escalas_raw, pd.DataFrame):
+        itens = escalas_raw.iloc[:, 0].tolist()
+    elif isinstance(escalas_raw, list):
+        itens = escalas_raw
+    else:
+        itens = [str(escalas_raw)]
 
     itens = [str(item) for item in itens if item and str(item).strip()]
-    if not itens: return "<p style='color: #6c757d; font-style: italic;'>Nenhuma transformação disponível.</p>"
+    if not itens:
+        return "<p style='color: #6c757d; font-style: italic;'>Nenhuma transformação disponível.</p>"
 
     max_chars = max(len(item) for item in itens)
     largura_min = max(150, max_chars * 7 + 28)
@@ -695,19 +509,22 @@ def formatar_escalas_html(escalas_raw):
     for item in itens:
         if ":" in item:
             partes = item.split(":", 1)
-            conteudo = f"""<span style="font-weight: 600; color: #495057;">{partes[0].strip()}:</span><span style="font-weight: 400; color: #6c757d; margin-left: 4px;">{partes[1].strip()}</span>"""
+            conteudo = (
+                f'<span style="font-weight: 600; color: #495057;">{partes[0].strip()}:</span>'
+                f'<span style="font-weight: 400; color: #6c757d; margin-left: 4px;">{partes[1].strip()}</span>'
+            )
         else:
-            conteudo = f"""<span style="font-weight: 600; color: #495057;">{item}</span>"""
-        cards_html += f"""<div class="dai-card-light" style="min-width: {largura_min}px;">{conteudo}</div>"""
+            conteudo = f'<span style="font-weight: 600; color: #495057;">{item}</span>'
+        cards_html += f'<div class="dai-card-light" style="min-width: {largura_min}px;">{conteudo}</div>'
 
-    return f"""<div class="dai-card">{criar_titulo_secao_html("Escalas / Transformações")}<div class="dai-cards-grid" style="grid-template-columns: repeat(auto-fill, minmax({largura_min}px, 1fr));">{cards_html}</div></div>"""
+    return (
+        f'<div class="dai-card">{criar_titulo_secao_html("Escalas / Transformações")}'
+        f'<div class="dai-cards-grid" style="grid-template-columns: repeat(auto-fill, minmax({largura_min}px, 1fr));">'
+        f"{cards_html}</div></div>"
+    )
 
 
 def _aplicar_jitter_sobrepostos(df_mapa, lat_col, lon_col, lat_plot_col, lon_plot_col):
-    """
-    Aplica jitter visual mínimo para separar pontos com coordenadas idênticas.
-    Não altera as coordenadas originais da base.
-    """
     df_plot = df_mapa.copy()
     df_plot[lat_plot_col] = pd.to_numeric(df_plot[lat_col], errors="coerce")
     df_plot[lon_plot_col] = pd.to_numeric(df_plot[lon_col], errors="coerce")
@@ -722,7 +539,6 @@ def _aplicar_jitter_sobrepostos(df_mapa, lat_col, lon_col, lat_plot_col, lon_plo
     passo_metros = 4.0
     max_raio_metros = 22.0
     metros_por_grau_lat = 111_320.0
-
     lat_plot_pos = int(df_plot.columns.get_loc(lat_plot_col))
     lon_plot_pos = int(df_plot.columns.get_loc(lon_plot_col))
 
@@ -743,7 +559,6 @@ def _aplicar_jitter_sobrepostos(df_mapa, lat_col, lon_col, lat_plot_col, lon_plo
         for pos, pos_idx in enumerate(posicoes):
             if pos == 0:
                 continue
-
             pos_ring = pos - 1
             ring = 1
             while pos_ring >= (6 * ring):
@@ -753,7 +568,6 @@ def _aplicar_jitter_sobrepostos(df_mapa, lat_col, lon_col, lat_plot_col, lon_plo
             slots_ring = max(6 * ring, 1)
             angulo = angulo_base + (2.0 * math.pi * (pos_ring / slots_ring))
             raio_m = min(ring * passo_metros, max_raio_metros)
-
             delta_lat = (raio_m * math.sin(angulo)) / metros_por_grau_lat
             delta_lon = (raio_m * math.cos(angulo)) / metros_por_grau_lon
 
@@ -791,8 +605,18 @@ def _montar_popup_registro_paginado(itens, popup_uid, max_itens_pagina=8):
     itens_por_pagina = max_itens_pagina * max_colunas_por_pagina
     paginas = [itens[i:i + itens_por_pagina] for i in range(0, len(itens), itens_por_pagina)]
     itens_primeira_pagina = len(paginas[0]) if paginas else 0
-    colunas_visiveis = max(1, min(max_colunas_por_pagina, int(math.ceil(itens_primeira_pagina / max_itens_pagina)) if itens_primeira_pagina else 1))
-    popup_largura_px = popup_padding_horizontal_px + (coluna_largura_px * colunas_visiveis) + (gap_cols_px * (colunas_visiveis - 1))
+    colunas_visiveis = max(
+        1,
+        min(
+            max_colunas_por_pagina,
+            int(math.ceil(itens_primeira_pagina / max_itens_pagina)) if itens_primeira_pagina else 1,
+        ),
+    )
+    popup_largura_px = (
+        popup_padding_horizontal_px
+        + (coluna_largura_px * colunas_visiveis)
+        + (gap_cols_px * (colunas_visiveis - 1))
+    )
 
     pages_html = []
     for page_idx, page_items in enumerate(paginas):
@@ -834,11 +658,11 @@ def _montar_popup_registro_paginado(itens, popup_uid, max_itens_pagina=8):
     if len(paginas) > 1:
         controls_html = (
             "<div class='mesa-popup-controls' style='display:flex; gap:5px; flex-wrap:nowrap; margin-top:8px; align-items:center; justify-content:center; white-space:nowrap; width:100%;'>"
-            f"<button type='button' data-page-nav='first' data-a='first' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&laquo;</button>"
-            f"<button type='button' data-page-nav='prev' data-a='prev' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&lsaquo;</button>"
+            "<button type='button' data-page-nav='first' data-a='first' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&laquo;</button>"
+            "<button type='button' data-page-nav='prev' data-a='prev' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&lsaquo;</button>"
             "<div data-page-number-wrap='1' style='display:flex; gap:5px; align-items:center; justify-content:center; flex-wrap:nowrap;'></div>"
-            f"<button type='button' data-page-nav='next' data-a='next' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&rsaquo;</button>"
-            f"<button type='button' data-page-nav='last' data-a='last' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&raquo;</button>"
+            "<button type='button' data-page-nav='next' data-a='next' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&rsaquo;</button>"
+            "<button type='button' data-page-nav='last' data-a='last' style=\"border:1px solid #ced8e2; background:#fff; border-radius:6px; padding:2px 7px; font-size:11px; cursor:pointer; color:#4e6479;\">&raquo;</button>"
             "</div>"
         )
 
@@ -901,9 +725,7 @@ def _montar_popup_registro_placeholder(session_id, row_id, popup_uid, popup_endp
     )
     return html, 380
 
-# ============================================================
-# FUNÇÃO: GERAR MAPA FOLIUM (com suporte a dimensionamento por variável)
-# ============================================================
+
 def criar_mapa(
     df,
     lat_col="lat",
@@ -916,20 +738,6 @@ def criar_mapa(
     popup_auth_token=None,
     avaliandos_tecnicos=None,
 ):
-    """
-    Cria mapa Folium com os dados, com suporte a dimensionamento proporcional.
-
-    Parâmetros:
-        df: DataFrame com os dados
-        lat_col: nome da coluna de latitude
-        lon_col: nome da coluna de longitude
-        cor_col: coluna para colorir os pontos (opcional)
-        tamanho_col: coluna numérica para dimensionar os círculos (opcional)
-
-    Retorna:
-        HTML do mapa
-    """
-    # Verifica se colunas existem (primeira ocorrência, robusto para colunas duplicadas)
     lat_real = None
     lon_real = None
     for col in df.columns:
@@ -950,7 +758,6 @@ def criar_mapa(
             return None
         return dataframe.iloc[:, matches[0]]
 
-    # Filtra dados válidos (numéricos e dentro dos limites geográficos)
     df_mapa = df.copy()
     lat_key = "__mesa_lat__"
     lon_key = "__mesa_lon__"
@@ -963,34 +770,30 @@ def criar_mapa(
     df_mapa[lon_key] = pd.to_numeric(lon_serie, errors="coerce")
     df_mapa = df_mapa.dropna(subset=[lat_key, lon_key])
     df_mapa = df_mapa[
-        (df_mapa[lat_key] >= -90.0) & (df_mapa[lat_key] <= 90.0) &
-        (df_mapa[lon_key] >= -180.0) & (df_mapa[lon_key] <= 180.0)
+        (df_mapa[lat_key] >= -90.0)
+        & (df_mapa[lat_key] <= 90.0)
+        & (df_mapa[lon_key] >= -180.0)
+        & (df_mapa[lon_key] <= 180.0)
     ].copy()
     if df_mapa.empty:
         return "<p>Sem coordenadas válidas para exibir.</p>"
 
-    # Cria mapa
     centro_lat = float(df_mapa[lat_key].median())
     centro_lon = float(df_mapa[lon_key].median())
-
-    m = folium.Map(
+    mapa = folium.Map(
         location=[centro_lat, centro_lon],
         zoom_start=12,
         tiles=None,
         prefer_canvas=True,
         control_scale=True,
     )
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=False).add_to(mapa)
+    add_bairros_layer(mapa, show=True)
 
-    # Camadas base
-    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=True).add_to(m)
-    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=False).add_to(m)
-    add_bairros_layer(m, show=True)
-
-    # Se tamanho_col fornecido mas cor_col não, usa mesma variável para cor
     if tamanho_col and tamanho_col != "Visualização Padrão" and not cor_col:
         cor_col = tamanho_col
 
-    # Colormap se houver coluna de cor (verde → vermelho)
     colormap = None
     cor_key = None
     if cor_col and cor_col in df_mapa.columns:
@@ -1005,11 +808,10 @@ def criar_mapa(
                     colors=["#2ecc71", "#a8e06c", "#f1c40f", "#e67e22", "#e74c3c"],
                     vmin=vmin,
                     vmax=vmax,
-                    caption=cor_col
+                    caption=cor_col,
                 )
-                colormap.add_to(m)
+                colormap.add_to(mapa)
 
-    # Escala de tamanho proporcional
     raio_min, raio_max = 3, 18
     tamanho_func = None
     tamanho_key = None
@@ -1055,15 +857,9 @@ def criar_mapa(
     contorno_padrao = 0.8 if total_pontos_plot <= 2500 else 0.55
     opacidade_preenchimento = 0.68 if total_pontos_plot <= 2500 else 0.6
 
-    # Adiciona pontos
     for marker_ordem, (idx, row) in enumerate(df_plot_pontos.iterrows()):
-        # Cor do ponto
-        if colormap and cor_key and pd.notna(row[cor_key]):
-            cor = colormap(row[cor_key])
-        else:
-            cor = COR_PRINCIPAL
+        cor = colormap(row[cor_key]) if colormap and cor_key and pd.notna(row[cor_key]) else COR_PRINCIPAL
 
-        # Calcula raio
         if tamanho_func and tamanho_key and pd.notna(row[tamanho_key]):
             raio = tamanho_func(row[tamanho_key])
             peso_contorno = 1
@@ -1071,8 +867,6 @@ def criar_mapa(
             raio = raio_padrao
             peso_contorno = contorno_padrao
 
-        # Tooltip (hover): índice + variável selecionada no dropdown (ou dependente como fallback)
-        # Usa coluna "index" (original, gerada pelo reset_index) quando disponível
         idx_display = int(row["index"]) if "index" in row.index else idx
         popup_uid = f"mesa-pop-{marker_ordem}"
         popup_html = None
@@ -1092,9 +886,9 @@ def criar_mapa(
                 popup_width = None
         if popup_html is None or popup_width is None:
             popup_html, popup_width = montar_popup_registro_html(row, popup_uid, max_itens_pagina=8)
+
         tooltip_html = (
-            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px;"
-            " line-height:1.7; padding:2px 4px;'>"
+            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px; line-height:1.7; padding:2px 4px;'>"
             f"<b>Índice {idx_display}</b>"
         )
         if tooltip_col and tooltip_key and tooltip_key in row.index:
@@ -1107,10 +901,7 @@ def criar_mapa(
                     val_str = f"{val_t:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
             else:
                 val_str = str(val_t)
-            tooltip_html += (
-                f"<br><span style='color:#555;'>{tooltip_col}:</span>"
-                f" <b>{val_str}</b>"
-            )
+            tooltip_html += f"<br><span style='color:#555;'>{tooltip_col}:</span> <b>{val_str}</b>"
         tooltip_html += "</div>"
 
         marcador = folium.CircleMarker(
@@ -1118,12 +909,12 @@ def criar_mapa(
             radius=raio,
             popup=folium.Popup(popup_html, max_width=popup_width),
             tooltip=folium.Tooltip(tooltip_html, sticky=True),
-            color='black',
+            color="black",
             weight=peso_contorno,
             fill=True,
             fillColor=cor,
-            fillOpacity=opacidade_preenchimento
-        ).add_to(m)
+            fillOpacity=opacidade_preenchimento,
+        ).add_to(mapa)
         marcador.options["mesaBaseRadius"] = float(max(1.0, raio))
 
         if mostrar_indices and camada_indices is not None:
@@ -1135,26 +926,24 @@ def criar_mapa(
             )
 
     if mostrar_indices and camada_indices is not None:
-        camada_indices.add_to(m)
+        camada_indices.add_to(mapa)
 
     if avaliandos_tecnicos:
         camada_trabalhos_tecnicos = folium.FeatureGroup(name="Avaliandos que usaram o modelo", show=True)
         add_trabalhos_tecnicos_markers(camada_trabalhos_tecnicos, avaliandos_tecnicos)
-        camada_trabalhos_tecnicos.add_to(m)
+        camada_trabalhos_tecnicos.add_to(mapa)
 
-    # Controles
-    folium.LayerControl().add_to(m)
-    plugins.Fullscreen().add_to(m)
+    folium.LayerControl().add_to(mapa)
+    plugins.Fullscreen().add_to(mapa)
     plugins.MeasureControl(
-        primary_length_unit='meters',
-        secondary_length_unit='kilometers',
-        primary_area_unit='sqmeters',
-        secondary_area_unit='hectares'
-    ).add_to(m)
-    add_zoom_responsive_circle_markers(m)
-    add_popup_pagination_handlers(m)
-
-    # Ajusta bounds robustos para evitar "salto" por pontos geocodificados distantes.
+        primary_length_unit="meters",
+        secondary_length_unit="kilometers",
+        primary_area_unit="sqmeters",
+        secondary_area_unit="hectares",
+    ).add_to(mapa)
+    add_zoom_responsive_circle_markers(mapa)
+    add_popup_pagination_handlers(mapa)
+
     df_bounds = df_mapa
     if len(df_mapa) >= 8:
         lat_vals = df_mapa[lat_key]
@@ -1163,12 +952,10 @@ def criar_mapa(
         lon_med = float(lon_vals.median())
         lat_mad = float((lat_vals - lat_med).abs().median())
         lon_mad = float((lon_vals - lon_med).abs().median())
-
         lat_span = float(lat_vals.max() - lat_vals.min())
         lon_span = float(lon_vals.max() - lon_vals.min())
         lat_scale = max(lat_mad, lat_span / 30.0, 1e-6)
         lon_scale = max(lon_mad, lon_span / 30.0, 1e-6)
-
         score = ((lat_vals - lat_med) / lat_scale) ** 2 + ((lon_vals - lon_med) / lon_scale) ** 2
         lim = float(score.quantile(0.75))
         df_core = df_mapa[score <= lim]
@@ -1196,326 +983,16 @@ def criar_mapa(
         lon_min = float(lon_min) - lon_delta
         lon_max = float(lon_max) + lon_delta
 
-    bounds = [[float(lat_min), float(lon_min)], [float(lat_max), float(lon_max)]]
-    m.fit_bounds(bounds, padding=(48, 48), max_zoom=18)
-
-    # Evita o wrapper de notebook (_repr_html_), que pode falhar dentro de iframe srcDoc.
-    return m.get_root().render()
-
-# ============================================================
-# FUNÇÃO: CARREGAR + VALIDAR MODELO (.dai)
-# ============================================================
-def carregar_modelo_gradio(arquivo):
-    if arquivo is None: return None, "Nenhum arquivo enviado."
-    try:
-        pacote = load(arquivo.name)
-        if not isinstance(pacote, dict): return None, "Arquivo inválido."
-        # Retrocompatibilidade: converte v1 (flat) para v2 (nested)
-        if "versao" not in pacote:
-            pacote = _migrar_pacote_v1_para_v2(pacote)
-        faltantes = [k for k in CHAVES_ESPERADAS if k not in pacote]
-        if faltantes: return None, f"Pacote incompleto. Faltando: {faltantes}"
-        return pacote, f"Modelo carregado: {os.path.basename(arquivo.name)}"
-    except Exception as e: return None, f"Erro: {e}"
-
-# ============================================================
-# FUNÇÃO: DESEMPACOTAR + EXIBIR CONTEÚDO
-# ============================================================
-def exibir_modelo(pacote):
-    # Retorna Nones se pacote vazio. Total de outputs = 14 (+ dropdown choices)
-    if pacote is None:
-        return [None] * 13 + [gr.update(choices=["Visualização Padrão"])]
-
-    # 1. Dados
-    dados = pacote["dados"]["df"].reset_index()
-    for col in dados.columns:
-        if str(col).lower() in ["lat", "lon"]: dados[col] = dados[col].round(6)
-        elif pd.api.types.is_numeric_dtype(dados[col]): dados[col] = dados[col].round(2)
-
-    # 2. Estatísticas
-    estat = pd.DataFrame(pacote["dados"]["estatisticas"])
-    if not isinstance(estat.index, pd.RangeIndex):
-        estat.insert(0, "Variável", estat.index.astype(str))
-        estat = estat.reset_index(drop=True)
-    estat = estat.round(2)
-
-    # 3. Escalas
-    escalas_html = formatar_escalas_html(pacote["transformacoes"]["info"])
-
-    # 4. X e y
-    X = pacote["transformacoes"]["X"].reset_index()
-    y = pacote["transformacoes"]["y"].reset_index()
-    if 'index' in y.columns and 'index' in X.columns: y = y.drop(columns=['index'])
-    df_X_y = pd.concat([X, y], axis=1).loc[:, ~pd.concat([X, y], axis=1).columns.duplicated()].round(2)
-
-    # 5. Resumo
-    resumo_html = formatar_resumo_html(reorganizar_modelos_resumos(pacote["modelo"]["diagnosticos"]))
-
-    # 6. Coeficientes
-    tab_coef = pd.DataFrame(pacote["modelo"]["coeficientes"])
-    if not isinstance(tab_coef.index, pd.RangeIndex):
-        tab_coef.insert(0, "Variável", tab_coef.index.astype(str))
-        tab_coef = tab_coef.reset_index(drop=True)
-    mask = tab_coef["Variável"].str.lower().isin(["intercept", "const", "(intercept)"])
-    if mask.any(): tab_coef = pd.concat([tab_coef[mask], tab_coef[~mask]], ignore_index=True)
-    tab_coef = tab_coef.round(2)
-
-    # 7. Obs x Calc
-    tab_obs_calc = pacote["modelo"]["obs_calc"].reset_index().round(2)
-
-    # 8. Gráficos (GERAÇÃO DINÂMICA)
-    figs_dict = gerar_todos_graficos(pacote)
-
-    # 9. Mapa
-    info_transf = pacote["transformacoes"]["info"]
-    nome_y = info_transf[0].split(": ", 1)[0].strip() if info_transf else None
-    mapa_html = criar_mapa(dados, col_y=nome_y)
-
-    # 10. Dropdown de variáveis para o mapa
-    colunas_numericas = [col for col in dados.select_dtypes(include=[np.number]).columns
-                         if str(col).lower() not in ['lat', 'lon', 'latitude', 'longitude', 'index']]
-    choices_mapa = ["Visualização Padrão"] + colunas_numericas
-
-    return (
-        dados,
-        estat,
-        escalas_html,
-        df_X_y,
-        resumo_html,
-        tab_coef,
-        tab_obs_calc,
-        figs_dict["obs_calc"],  # Plot 1
-        figs_dict["residuos"],  # Plot 2
-        figs_dict["hist"],      # Plot 3
-        figs_dict["cook"],      # Plot 4
-        figs_dict["corr"],      # Plot 5
-        mapa_html,
-        gr.update(choices=choices_mapa, value="Visualização Padrão")  # Dropdown update
-    )
-
-
-def atualizar_mapa_callback(dados, var_mapa, pacote):
-    """Atualiza o mapa quando a variável de dimensionamento é alterada."""
-    if dados is None or dados.empty:
-        return "<p>Carregue dados para ver o mapa.</p>"
-
-    tamanho_col = None if var_mapa == "Visualização Padrão" else var_mapa
-    nome_y = None
-    if pacote:
-        info_transf = pacote["transformacoes"]["info"]
-        nome_y = info_transf[0].split(": ", 1)[0].strip() if info_transf else None
-    return criar_mapa(dados, tamanho_col=tamanho_col, col_y=nome_y)
-
-def popular_inputs_avaliacao(pacote):
-    """Popula campos de avaliação a partir do pacote .dai carregado.
-
-    CONTRACT: Retorna 30 itens (N_ROWS_AVAL + MAX_VARS_AVAL).
-    """
-    rows_hidden = [gr.update(visible=False)] * N_ROWS_AVAL
-    inputs_hidden = [gr.update(visible=False, value=None, label="")] * MAX_VARS_AVAL
-
-    if pacote is None:
-        return (*rows_hidden, *inputs_hidden)
-
-    info_transf = pacote["transformacoes"]["info"]
-    estatisticas = pacote["dados"]["estatisticas"]
-    # Normaliza para string — colunas_x vem de split de strings, mas listas do DAI
-    # podem ter inteiros se o CSV original tinha colunas numéricas (ex: anos 2015, 2016...)
-    dicotomicas = [str(d) for d in (pacote["transformacoes"].get("dicotomicas", []) or [])]
-    codigo_alocado = [str(c) for c in (pacote["transformacoes"].get("codigo_alocado", []) or [])]
-    percentuais = [str(p) for p in (pacote["transformacoes"].get("percentuais", []) or [])]
-
-    colunas_x = []
-    for item in info_transf[1:]:
-        nome_x, _ = item.split(": ", 1)
-        colunas_x.append(nome_x.strip())
-
-    n_vars = len(colunas_x)
-    n_rows_vis = math.ceil(n_vars / N_COLS_AVAL)
-
-    if estatisticas is not None:
-        est = pd.DataFrame(estatisticas)
-        if "Variável" in est.columns:
-            est_idx = est.set_index("Variável")
-        elif not isinstance(est.index, pd.RangeIndex):
-            est_idx = est
-        else:
-            est_idx = pd.DataFrame()
-        # Normaliza index para string (mesmo motivo das listas acima)
-        if not est_idx.empty:
-            est_idx.index = est_idx.index.map(str)
-    else:
-        est_idx = pd.DataFrame()
-
-    rows_updates = [gr.update(visible=(r < n_rows_vis)) for r in range(N_ROWS_AVAL)]
-
-    inputs_updates = []
-    for i in range(MAX_VARS_AVAL):
-        if i < n_vars:
-            col = colunas_x[i]
-            if col in dicotomicas:
-                placeholder = "0 ou 1"
-            elif col in codigo_alocado and col in est_idx.index:
-                min_val = est_idx.loc[col, "Mínimo"]
-                max_val = est_idx.loc[col, "Máximo"]
-                placeholder = f"cód. {int(min_val)} a {int(max_val)}"
-            elif col in percentuais:
-                placeholder = "0 a 1"
-            elif col in est_idx.index:
-                min_val = est_idx.loc[col, "Mínimo"]
-                max_val = est_idx.loc[col, "Máximo"]
-                placeholder = f"{min_val} — {max_val}"
-            else:
-                placeholder = ""
-            inputs_updates.append(gr.update(visible=True, value=None, label=col, placeholder=placeholder, interactive=True))
-        else:
-            inputs_updates.append(gr.update(visible=False, value=None, label="", placeholder=""))
-
-    return (*rows_updates, *inputs_updates)
-
-
-def calcular_avaliacao_viz(pacote, estado_avaliacoes, indice_base_str, *aval_inputs):
-    """Calcula avaliação usando o modelo carregado na aba Visualização.
-
-    CONTRACT: Retorna 3 itens (resultado_html, estado_avaliacoes, dropdown_update).
-    """
-    _err = lambda msg: (msg, estado_avaliacoes or [], gr.update())
-    if pacote is None:
-        return _err("Carregue e exiba um modelo primeiro.")
-
-    info_transf = pacote["transformacoes"]["info"]
-    nome_y, transf_y = info_transf[0].split(": ", 1)
-    transformacao_y = transf_y.strip().replace("(y)", "(x)")
-
-    colunas_x = []
-    transformacoes_x = {}
-    for item in info_transf[1:]:
-        nome_x, transf_x = item.split(": ", 1)
-        nome_x = nome_x.strip()
-        colunas_x.append(nome_x)
-        transformacoes_x[nome_x] = transf_x.strip()
-
-    valores_x = {}
-    for i, col in enumerate(colunas_x):
-        if i >= len(aval_inputs) or aval_inputs[i] is None:
-            return _err("Preencha todos os campos.")
-        valores_x[col] = float(aval_inputs[i])
-
-    # Validar variáveis dicotômicas, categóricas codificadas e percentuais ANTES de avaliar
-    dicotomicas = pacote["transformacoes"].get("dicotomicas", [])
-    codigo_alocado = pacote["transformacoes"].get("codigo_alocado", [])
-    percentuais = pacote["transformacoes"].get("percentuais", [])
-    estatisticas_df = pacote["dados"]["estatisticas"]
-    import pandas as pd
-    if isinstance(estatisticas_df, pd.DataFrame):
-        if "Variável" in estatisticas_df.columns:
-            est_idx = estatisticas_df.set_index("Variável")
-        else:
-            est_idx = estatisticas_df
-    else:
-        est_idx = pd.DataFrame()
-
-    for col in colunas_x:
-        val = valores_x[col]
-        if col in (dicotomicas or []):
-            if val not in (0, 0.0, 1, 1.0):
-                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é dicotômica e aceita apenas valores 0 ou 1. "
-                        f"Valor informado: {val}</p>")
-        elif col in (codigo_alocado or []) and col in est_idx.index:
-            min_val = float(est_idx.loc[col, "Mínimo"])
-            max_val = float(est_idx.loc[col, "Máximo"])
-            eh_inteiro = (float(val) == int(float(val)))
-            if not eh_inteiro or val < min_val or val > max_val:
-                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é categórica codificada e aceita apenas "
-                        f"valores inteiros de {int(min_val)} a {int(max_val)}. Valor informado: {val}</p>")
-        elif col in (percentuais or []):
-            if val < 0 or val > 1:
-                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é percentual e aceita apenas "
-                        f"valores entre 0 e 1. Valor informado: {val}</p>")
-
-    resultado = avaliar_imovel(
-        modelo_sm=pacote["modelo"]["sm"],
-        valores_x=valores_x,
-        colunas_x=colunas_x,
-        transformacoes_x=transformacoes_x,
-        transformacao_y=transformacao_y,
-        estatisticas_df=estatisticas_df,
-        dicotomicas=dicotomicas,
-        codigo_alocado=codigo_alocado,
-        percentuais=percentuais,
-    )
-
-    if resultado is None:
-        return _err("Erro ao calcular avaliação.")
-
-    nova_lista = list(estado_avaliacoes or []) + [resultado]
-    indice_base = int(indice_base_str) - 1 if indice_base_str else 0
-    html = formatar_avaliacao_html(nova_lista, indice_base=indice_base, elem_id_excluir="excluir-aval-viz")
-    choices = [str(i + 1) for i in range(len(nova_lista))]
-    base_val = indice_base_str if indice_base_str else "1"
-    return html, nova_lista, gr.update(choices=choices, value=base_val)
-
-
-def excluir_avaliacao_viz(indice_str, estado_avaliacoes, indice_base_str):
-    """Exclui uma avaliação (Visualização).
-
-    CONTRACT: Retorna 4 itens (resultado_html, estado_avaliacoes, dropdown_update, trigger_reset).
-    """
-    if not indice_str or not indice_str.strip() or not estado_avaliacoes:
-        return gr.update(), estado_avaliacoes or [], gr.update(), ""
-    try:
-        idx = int(indice_str.strip()) - 1
-    except ValueError:
-        return gr.update(), estado_avaliacoes or [], gr.update(), ""
-    if idx < 0 or idx >= len(estado_avaliacoes):
-        return gr.update(), estado_avaliacoes or [], gr.update(), ""
-
-    nova_lista = [a for i, a in enumerate(estado_avaliacoes) if i != idx]
-    if not nova_lista:
-        return "", [], gr.update(choices=[], value=None), ""
-
-    base = int(indice_base_str) - 1 if indice_base_str else 0
-    if base >= len(nova_lista):
-        base = len(nova_lista) - 1
-    if base < 0:
-        base = 0
-
-    choices = [str(i + 1) for i in range(len(nova_lista))]
-    html = formatar_avaliacao_html(nova_lista, indice_base=base, elem_id_excluir="excluir-aval-viz")
-    return html, nova_lista, gr.update(choices=choices, value=str(base + 1)), ""
-
-
-def atualizar_base_avaliacao_viz(estado_avaliacoes, indice_base_str):
-    """Re-renderiza HTML quando o dropdown de base muda (Visualização)."""
-    if not estado_avaliacoes:
-        return ""
-    indice = int(indice_base_str) - 1 if indice_base_str else 0
-    return formatar_avaliacao_html(estado_avaliacoes, indice_base=indice, elem_id_excluir="excluir-aval-viz")
-
-
-def exportar_avaliacoes_excel_viz(estado_avaliacoes):
-    """Exporta avaliações para Excel (Visualização)."""
-    if not estado_avaliacoes:
-        return gr.update(value=None, visible=False)
-    caminho = exportar_avaliacoes_excel(estado_avaliacoes)
-    if caminho:
-        return gr.update(value=caminho, visible=True)
-    return gr.update(value=None, visible=False)
+    mapa.fit_bounds([[float(lat_min), float(lon_min)], [float(lat_max), float(lon_max)]], padding=(48, 48), max_zoom=18)
+    return mapa.get_root().render()
 
 
 def _formatar_badge_completo(pacote, nome_modelo=""):
-    """Retorna HTML do badge no mesmo padrão visual da aba Elaboração."""
     if not pacote:
         return ""
 
     def _esc(value):
-        return (
-            str(value or "")
-            .replace("&", "&amp;")
-            .replace("<", "&lt;")
-            .replace(">", "&gt;")
-            .replace('"', "&quot;")
-        )
+        return str(value or "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
 
     def _data_br(value):
         texto = str(value or "").strip()
@@ -1525,24 +1002,21 @@ def _formatar_badge_completo(pacote, nome_modelo=""):
         match_iso = re.match(r"^(\d{4})-(\d{2})-(\d{2})(?:[T\s].*)?$", texto)
         if match_iso:
             try:
-                dt = datetime(int(match_iso.group(1)), int(match_iso.group(2)), int(match_iso.group(3)))
-                return dt.strftime("%d/%m/%Y")
+                return datetime(int(match_iso.group(1)), int(match_iso.group(2)), int(match_iso.group(3))).strftime("%d/%m/%Y")
             except Exception:
                 return texto
 
         match_iso_slash = re.match(r"^(\d{4})/(\d{2})/(\d{2})(?:[T\s].*)?$", texto)
         if match_iso_slash:
             try:
-                dt = datetime(int(match_iso_slash.group(1)), int(match_iso_slash.group(2)), int(match_iso_slash.group(3)))
-                return dt.strftime("%d/%m/%Y")
+                return datetime(int(match_iso_slash.group(1)), int(match_iso_slash.group(2)), int(match_iso_slash.group(3))).strftime("%d/%m/%Y")
             except Exception:
                 return texto
 
         match_br = re.match(r"^(\d{2})/(\d{2})/(\d{4})(?:[T\s].*)?$", texto)
         if match_br:
             try:
-                dt = datetime(int(match_br.group(3)), int(match_br.group(2)), int(match_br.group(1)))
-                return dt.strftime("%d/%m/%Y")
+                return datetime(int(match_br.group(3)), int(match_br.group(2)), int(match_br.group(1))).strftime("%d/%m/%Y")
             except Exception:
                 return texto
 
@@ -1550,7 +1024,6 @@ def _formatar_badge_completo(pacote, nome_modelo=""):
 
     model_name = str(nome_modelo or "").strip() or "-"
     observacao_modelo = str(pacote.get("observacao_modelo") or "").strip()
-
     periodo = pacote.get("periodo_dados_mercado") or {}
     data_inicial = _data_br(periodo.get("data_inicial"))
     data_final = _data_br(periodo.get("data_final"))
@@ -1659,254 +1132,19 @@ def _formatar_badge_completo(pacote, nome_modelo=""):
         "<div class='modelo-info-card'>"
         "<div class='modelo-info-split'>"
         "<div class='modelo-info-col'>"
-        + nome_modelo_html +
-        "<div class='modelo-info-stack-block'>"
+        + nome_modelo_html
+        + "<div class='modelo-info-stack-block'>"
         "<div class='elaborador-badge-title'>ELABORADO POR:</div>"
-        + elaborador_html +
-        "</div>"
+        + elaborador_html
+        + "</div>"
         "</div>"
         "<div class='modelo-info-col modelo-info-col-vars'>"
         "<div class='elaborador-badge-title'>Variáveis selecionadas:</div>"
-        + y_html +
-        x_html +
-        periodo_html +
-        "</div>"
+        + y_html
+        + x_html
+        + periodo_html
+        + "</div>"
         "</div>"
         "</div>"
         "</div>"
     )
-
-
-def limpar_tudo():
-    return (
-        None, "", None, None, None, "", None, "", None, None,
-        None, None, None, None, None, # 5 gráficos nulos
-        "", None,
-        gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),  # Dropdown reset
-        # Reset avaliação
-        *[gr.update(visible=False) for _ in range(N_ROWS_AVAL)],
-        *[gr.update(visible=False, value=None, label="") for _ in range(MAX_VARS_AVAL)],
-        "",  # resultado_aval_html
-        [],  # estado_avaliacoes
-        gr.update(choices=[], value=None),  # dropdown_base_aval
-        "",  # excluir_aval_trigger_viz
-        gr.update(value=None, visible=False),  # download_aval_file
-        "",  # elaborador_badge
-    )
-
-# ============================================================
-# INTERFACE GRADIO
-# ============================================================
-
-description = f"""
-# <p style="text-align: center;">MODELOS ESTATÍSTICOS</p>
-<p style="text-align: center;">Divisão de Avaliação de Imóveis</p>
-<hr style="color: #333; background-color: #333; height: 1px; border: none;">
-"""
-
-def criar_aba():
-    """Cria conteúdo da aba de visualização (sem wrapper gr.Blocks)."""
-    # --------------------------------------------------------
-    # ESTADO
-    # --------------------------------------------------------
-    estado_pacote = gr.State(None)
-    estado_dados = gr.State(None)  # Armazena os dados para atualizar o mapa
-
-    # --------------------------------------------------------
-    # CONTROLES (TOPO)
-    # --------------------------------------------------------
-    with gr.Group(elem_classes="upload-area"):
-        upload = gr.File(label="Enviar modelo salvo (.dai)", file_types=[".dai"], scale=1)
-        with gr.Row(equal_height=True):
-            status = gr.Textbox(show_label=False, interactive=False, scale=4, lines=1)
-        elaborador_badge = gr.HTML("")
-        with gr.Row(equal_height=True):
-            btn_exibir = gr.Button("Exibir modelo", scale=2, variant="primary")
-            btn_limpar = gr.Button("Limpar tudo", scale=1, variant="secondary")
-
-    # --------------------------------------------------------
-    # MAPA (RETRÁTIL VIA ACCORDION)
-    # --------------------------------------------------------
-    with gr.Accordion("Mapa de Distribuição dos Dados", open=True, elem_classes="map-accordion"):
-        dropdown_mapa_var = gr.Dropdown(
-            label="Variável para dimensionar pontos no mapa",
-            choices=["Visualização Padrão"],
-            value="Visualização Padrão",
-            interactive=True,
-            allow_custom_value=False
-        )
-        out_mapa = gr.HTML(label="", elem_id="map-frame")
-
-    # --------------------------------------------------------
-    # CONTEÚDO (LARGURA TOTAL)
-    # --------------------------------------------------------
-    with gr.Column(elem_classes="content-panel"):
-            with gr.Tabs(elem_classes="tabs-container"):
-                with gr.Tab("Dados"):
-                    gr.HTML(criar_titulo_secao_html("Dados Utilizados"))
-                    out_dados = gr.Dataframe(show_label=False, max_height=300)
-                    gr.HTML(criar_titulo_secao_html("Estatísticas"))
-                    out_estat = gr.Dataframe(show_label=False, max_height=300)
-
-                with gr.Tab("Transformações"):
-                    out_escalas = gr.HTML()
-                    gr.HTML(criar_titulo_secao_html("X e y Transformados"))
-                    out_df_xy = gr.Dataframe(show_label=False, max_height=400)
-
-                with gr.Tab("Resumo"):
-                    out_resumo = gr.HTML()
-
-                with gr.Tab("Coeficientes"):
-                    gr.HTML(criar_titulo_secao_html("Tabela de Coeficientes"))
-                    out_coef = gr.Dataframe(show_label=False, max_height=700)
-
-                with gr.Tab("Obs x Calc"):
-                    gr.HTML(criar_titulo_secao_html("Tabela Obs x Calc"))
-                    out_obs = gr.Dataframe(show_label=False, max_height=600)
-
-                with gr.Tab("Gráficos") as tab_graficos:
-                    with gr.Group():
-                        # Linha 1 — dois gráficos, 50% / 50%
-                        with gr.Row():
-                            out_plot_obs = gr.Plot(label="Obs vs Calc")
-                            out_plot_res = gr.Plot(label="Resíduos vs Ajustados")
-
-                        # Linha 2 — dois gráficos, 50% / 50%
-                        with gr.Row():
-                            out_plot_hist = gr.Plot(label="Histograma Resíduos")
-                            out_plot_cook = gr.Plot(label="Distância de Cook")
-
-                        # Linha 3 — gráfico sozinho, largura máxima
-                        with gr.Row():
-                            out_plot_corr = gr.Plot(label="Correlação")
-
-                with gr.Tab("Avaliação"):
-                    gr.HTML(criar_titulo_secao_html("Avaliação Individual"))
-                    aval_rows = []
-                    aval_inputs = []
-                    with gr.Column(elem_classes="aval-all-cards"):
-                        for _i_row in range(N_ROWS_AVAL):
-                            with gr.Row(visible=False, elem_classes="aval-cards-row") as _aval_row:
-                                for _j_col in range(N_COLS_AVAL):
-                                    _inp = gr.Number(label="", visible=False, interactive=True, elem_classes="aval-card")
-                                    aval_inputs.append(_inp)
-                            aval_rows.append(_aval_row)
-                    with gr.Row():
-                        btn_calcular_aval = gr.Button("Calcular", variant="primary", scale=2)
-                        btn_limpar_aval = gr.Button("Limpar", variant="secondary", scale=1)
-                        dropdown_base_aval = gr.Dropdown(
-                            label="Base p/ comparação",
-                            choices=[],
-                            value=None,
-                            interactive=True,
-                            scale=1,
-                        )
-                    resultado_aval_html = gr.HTML("")
-                    excluir_aval_trigger_viz = gr.Textbox(
-                        label="", elem_id="excluir-aval-viz", container=False,
-                        elem_classes="trigger-hidden"
-                    )
-                    estado_avaliacoes = gr.State([])
-                    with gr.Row():
-                        btn_exportar_aval = gr.Button("Salvar Avaliações em Excel", variant="secondary")
-                        download_aval_file = gr.File(label="", visible=False)
-
-                with gr.Tab("Avaliação em Massa"):
-                    gr.HTML(criar_titulo_secao_html("Avaliação em Lote"))
-                    gr.HTML("""<div class="placeholder-alert"><p>Módulo em desenvolvimento</p></div>""")
-
-    # --------------------------------------------------------
-    # EVENTOS
-    # --------------------------------------------------------
-    upload.upload(
-        carregar_modelo_gradio, inputs=upload, outputs=[estado_pacote, status]
-    ).then(
-        _formatar_badge_completo, inputs=estado_pacote, outputs=elaborador_badge
-    )
-
-    btn_exibir.click(
-        exibir_modelo,
-        inputs=estado_pacote,
-        outputs=[
-            out_dados, out_estat, out_escalas, out_df_xy, out_resumo, out_coef, out_obs,
-            out_plot_obs, out_plot_res, out_plot_hist, out_plot_cook, out_plot_corr,
-            out_mapa, dropdown_mapa_var
-        ],
-    ).then(
-        popular_inputs_avaliacao,
-        inputs=estado_pacote,
-        outputs=aval_rows + aval_inputs
-    ).then(
-        lambda x: x,  # Copia out_dados para estado_dados
-        inputs=out_dados,
-        outputs=estado_dados
-    )
-
-    # Atualiza mapa quando dropdown muda
-    dropdown_mapa_var.change(
-        atualizar_mapa_callback,
-        inputs=[estado_dados, dropdown_mapa_var, estado_pacote],
-        outputs=out_mapa
-    )
-
-    btn_limpar.click(
-        limpar_tudo,
-        outputs=[
-            estado_pacote, status, upload,
-            out_dados, out_estat, out_escalas, out_df_xy, out_resumo, out_coef, out_obs,
-            out_plot_obs, out_plot_res, out_plot_hist, out_plot_cook, out_plot_corr,
-            out_mapa, estado_dados,
-            dropdown_mapa_var,
-        ] + aval_rows + aval_inputs + [resultado_aval_html, estado_avaliacoes,
-            dropdown_base_aval, excluir_aval_trigger_viz, download_aval_file,
-            elaborador_badge]
-    )
-
-    # Avaliação individual
-    btn_calcular_aval.click(
-        calcular_avaliacao_viz,
-        inputs=[estado_pacote, estado_avaliacoes, dropdown_base_aval] + aval_inputs,
-        outputs=[resultado_aval_html, estado_avaliacoes, dropdown_base_aval]
-    )
-
-    btn_limpar_aval.click(
-        lambda: ("", [], gr.update(choices=[], value=None)),
-        outputs=[resultado_aval_html, estado_avaliacoes, dropdown_base_aval]
-    )
-
-    excluir_aval_trigger_viz.change(
-        excluir_avaliacao_viz,
-        inputs=[excluir_aval_trigger_viz, estado_avaliacoes, dropdown_base_aval],
-        outputs=[resultado_aval_html, estado_avaliacoes, dropdown_base_aval, excluir_aval_trigger_viz]
-    )
-
-    dropdown_base_aval.change(
-        atualizar_base_avaliacao_viz,
-        inputs=[estado_avaliacoes, dropdown_base_aval],
-        outputs=[resultado_aval_html]
-    )
-
-    btn_exportar_aval.click(
-        exportar_avaliacoes_excel_viz,
-        inputs=[estado_avaliacoes],
-        outputs=[download_aval_file]
-    )
-
-    # Força Plotly a recalcular tamanho quando a tab Gráficos é selecionada
-    tab_graficos.select(
-        fn=None,
-        inputs=None,
-        outputs=None,
-        js="() => { setTimeout(() => window.dispatchEvent(new Event('resize')), 100) }"
-    )
-
-
-# ============================================================
-# EXECUÇÃO
-# ============================================================
-if __name__ == "__main__":
-    custom_css = carregar_css()
-    with gr.Blocks(css=custom_css) as app:
-        gr.Markdown(description)
-        criar_aba()
-    app.launch()

backend/app/runtime_config.py

@@ -140,17 +140,27 @@ def apply_runtime_config(config_path: str | Path | None = None) -> RuntimeSettin
 
     os.environ.setdefault("MESA_RUNTIME_DIR", str(runtime_dir))
 
+    data_base_dir = _expand_path(paths_cfg.get("data_base_dir"), base_dir=config_base_dir)
+    if data_base_dir is not None:
+        os.environ["MESA_DATA_BASE_DIR"] = str(data_base_dir)
+
     models_dir = _expand_path(paths_cfg.get("models_dir"), base_dir=config_base_dir)
+    if models_dir is None and data_base_dir is not None:
+        models_dir = (data_base_dir / "modelos_dai").resolve()
     if models_dir is not None:
         os.environ["MODELOS_REPOSITORIO_PROVIDER"] = "local"
         os.environ["MODELOS_REPOSITORIO_LOCAL_DIR"] = str(models_dir)
 
     trabalhos_db = _expand_path(paths_cfg.get("trabalhos_tecnicos_db"), base_dir=config_base_dir)
+    if trabalhos_db is None and data_base_dir is not None:
+        trabalhos_db = (data_base_dir / "trabalhos_tecnicos" / "trabalhos_tecnicos.sqlite3").resolve()
     if trabalhos_db is not None:
         os.environ["TRABALHOS_TECNICOS_PROVIDER"] = "local"
         os.environ["TRABALHOS_TECNICOS_DB_LOCAL_PATH"] = str(trabalhos_db)
 
     users_file = _expand_path(paths_cfg.get("users_file"), base_dir=config_base_dir)
+    if users_file is None and data_base_dir is not None:
+        users_file = (data_base_dir / "usuarios" / "usuarios.json").resolve()
     if users_file is not None:
         os.environ["APP_USERS_FILE"] = str(users_file)
 

backend/requirements.txt

@@ -15,5 +15,4 @@ openpyxl
 pyshp
 geopandas
 fiona
-gradio>=4.0
 huggingface_hub>=0.30.0

build/windows/appsettings.example.json

@@ -5,9 +5,7 @@
     "open_browser": true
   },
   "paths": {
-    "models_dir": "..\\dados\\modelos_dai",
-    "trabalhos_tecnicos_db": "..\\dados\\trabalhos_tecnicos\\trabalhos_tecnicos.sqlite3",
-    "users_file": "..\\dados\\usuarios\\usuarios.json"
+    "data_base_dir": "../dados"
   },
   "env": {
     "APP_LOGS_MODE": "disabled"

build/windows/build_portable.ps1

@@ -20,6 +20,7 @@ python -m PyInstaller build/windows/mesa_frame_portable.spec --noconfirm --clean
 Write-Host "[mesa] provision external config folder"
 New-Item -ItemType Directory -Force -Path "dist/MesaFrame/config" | Out-Null
 Copy-Item "build/windows/appsettings.example.json" "dist/MesaFrame/config/appsettings.example.json" -Force
+Copy-Item "build/windows/appsettings.example.json" "dist/MesaFrame/config/appsettings.json" -Force
 
 if (Test-Path "dist/MesaFrame-portable.zip") {
   Remove-Item "dist/MesaFrame-portable.zip" -Force

build/windows/mesa_frame_portable.spec

@@ -16,8 +16,6 @@ datas = [
 if LOCAL_DATA_DIR.exists():
     datas.append((str(LOCAL_DATA_DIR), "local_data"))
 datas += collect_data_files("safehttpx")
-datas += collect_data_files("gradio")
-datas += collect_data_files("gradio_client")
 datas += collect_data_files("fiona")
 datas += collect_data_files("geopandas")
 datas += collect_data_files("pyproj")

build/windows/package_portable_release.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_USERS_FILE = REPO_ROOT / "backend" / "app" / "core" / "auth" / "usuarios.json"
+DEFAULT_MODELS_DIR = REPO_ROOT / "backend" / "app" / "core" / "pesquisa" / "modelos_dai"
+DEFAULT_TRABALHOS_DB = REPO_ROOT / "backend" / "local_data" / "trabalhos_tecnicos.sqlite3"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Monta o zip final portatil do MesaFrame com dados externos e modelos."
+    )
+    parser.add_argument(
+        "--artifact-zip",
+        type=Path,
+        required=True,
+        help="Zip baixado do artifact do GitHub Actions.",
+    )
+    parser.add_argument(
+        "--output-zip",
+        type=Path,
+        required=True,
+        help="Caminho do zip final a ser gerado.",
+    )
+    parser.add_argument(
+        "--users-file",
+        type=Path,
+        default=DEFAULT_USERS_FILE,
+        help="Arquivo usuarios.json a incluir em dados/usuarios.",
+    )
+    parser.add_argument(
+        "--models-dir",
+        type=Path,
+        default=DEFAULT_MODELS_DIR,
+        help="Pasta local com os arquivos .dai.",
+    )
+    parser.add_argument(
+        "--trabalhos-db",
+        type=Path,
+        default=DEFAULT_TRABALHOS_DB,
+        help="SQLite de trabalhos tecnicos a incluir em dados/trabalhos_tecnicos.",
+    )
+    return parser.parse_args()
+
+
+def extract_zip(zip_path: Path, target_dir: Path) -> None:
+    with zipfile.ZipFile(zip_path, "r") as archive:
+        archive.extractall(target_dir)
+
+
+def find_inner_portable_zip(extracted_artifact_dir: Path) -> Path:
+    matches = sorted(extracted_artifact_dir.rglob("MesaFrame-portable.zip"))
+    if not matches:
+        raise FileNotFoundError(
+            f"Nao encontrei MesaFrame-portable.zip dentro de {extracted_artifact_dir}"
+        )
+    return matches[0]
+
+
+def ensure_file(path: Path, label: str) -> Path:
+    if not path.exists():
+        raise FileNotFoundError(f"{label} nao encontrado: {path}")
+    return path
+
+
+def write_runtime_config(config_path: Path) -> None:
+    payload = {
+        "server": {
+            "host": "127.0.0.1",
+            "port": 8000,
+            "open_browser": True,
+        },
+        "paths": {
+            "data_base_dir": "../dados",
+        },
+        "env": {
+            "APP_LOGS_MODE": "disabled",
+        },
+    }
+    config_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def copy_tree_contents(source_dir: Path, target_dir: Path) -> None:
+    for item in source_dir.iterdir():
+        destination = target_dir / item.name
+        if item.is_dir():
+            shutil.copytree(item, destination)
+        else:
+            shutil.copy2(item, destination)
+
+
+def copy_models(models_dir: Path, target_models_dir: Path) -> int:
+    target_models_dir.mkdir(parents=True, exist_ok=True)
+    copied = 0
+    for model_file in sorted(models_dir.glob("*.dai")):
+        shutil.copy2(model_file, target_models_dir / model_file.name)
+        copied += 1
+    if copied == 0:
+        raise RuntimeError(f"Nenhum arquivo .dai encontrado em {models_dir}")
+    return copied
+
+
+def create_zip(source_dir: Path, output_zip: Path) -> None:
+    output_zip.parent.mkdir(parents=True, exist_ok=True)
+    if output_zip.exists():
+        output_zip.unlink()
+    with zipfile.ZipFile(output_zip, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as archive:
+        for file_path in sorted(source_dir.rglob("*")):
+            archive.write(file_path, file_path.relative_to(source_dir))
+
+
+def main() -> None:
+    args = parse_args()
+
+    artifact_zip = ensure_file(args.artifact_zip.resolve(), "Artifact zip")
+    users_file = ensure_file(args.users_file.resolve(), "usuarios.json")
+    trabalhos_db = ensure_file(args.trabalhos_db.resolve(), "SQLite de trabalhos tecnicos")
+    models_dir = ensure_file(args.models_dir.resolve(), "Pasta de modelos")
+    output_zip = args.output_zip.resolve()
+
+    with tempfile.TemporaryDirectory(prefix="mesa-frame-release-") as temp_dir_str:
+        temp_dir = Path(temp_dir_str)
+        artifact_dir = temp_dir / "artifact"
+        portable_dir = temp_dir / "portable"
+        stage_dir = temp_dir / "stage"
+
+        extract_zip(artifact_zip, artifact_dir)
+        inner_zip = find_inner_portable_zip(artifact_dir)
+        extract_zip(inner_zip, portable_dir)
+
+        source_app_dir = portable_dir / "MesaFrame"
+        if not source_app_dir.exists():
+            raise FileNotFoundError(f"Pasta MesaFrame nao encontrada dentro de {inner_zip}")
+
+        final_app_dir = stage_dir / "MesaFrame"
+        final_app_dir.mkdir(parents=True, exist_ok=True)
+        copy_tree_contents(source_app_dir, final_app_dir)
+
+        config_dir = final_app_dir / "config"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        write_runtime_config(config_dir / "appsettings.json")
+        shutil.copy2(REPO_ROOT / "build" / "windows" / "appsettings.example.json", config_dir / "appsettings.example.json")
+
+        data_base_dir = final_app_dir / "dados"
+        models_target_dir = data_base_dir / "modelos_dai"
+        users_target_dir = data_base_dir / "usuarios"
+        trabalhos_target_dir = data_base_dir / "trabalhos_tecnicos"
+
+        users_target_dir.mkdir(parents=True, exist_ok=True)
+        trabalhos_target_dir.mkdir(parents=True, exist_ok=True)
+
+        models_count = copy_models(models_dir, models_target_dir)
+        shutil.copy2(users_file, users_target_dir / "usuarios.json")
+        shutil.copy2(trabalhos_db, trabalhos_target_dir / "trabalhos_tecnicos.sqlite3")
+
+        create_zip(stage_dir, output_zip)
+        print(
+            json.dumps(
+                {
+                    "ok": True,
+                    "output_zip": str(output_zip),
+                    "models_count": models_count,
+                    "users_file": str(users_file),
+                    "trabalhos_db": str(trabalhos_db),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+
+
+if __name__ == "__main__":
+    main()