correcoes de overflows e normalizacoes de tipos

backend/app/core/elaboracao/core.py

@@ -83,6 +83,75 @@ def detectar_abas_excel(arquivo):
         return [], f"Erro ao detectar abas: {str(e)}", False
 
 
+def _normalizar_colunas_numericas_texto(df, proporcao_minima=0.9):
+    """
+    Converte colunas textuais numericamente consistentes para dtype numérico.
+
+    Objetivo:
+    - preservar colunas realmente textuais;
+    - recuperar números em formatos comuns (pt-BR e en-US), como:
+      1.234,56 | 1234.56 | 0,25 | 0.25.
+    """
+    if df is None or df.empty:
+        return df
+
+    df_saida = df.copy()
+
+    for col in df_saida.columns:
+        serie = df_saida[col]
+        if (
+            pd.api.types.is_numeric_dtype(serie)
+            or pd.api.types.is_bool_dtype(serie)
+            or pd.api.types.is_datetime64_any_dtype(serie)
+        ):
+            continue
+
+        texto = serie.astype(str).str.strip().replace({
+            "": np.nan,
+            "nan": np.nan,
+            "NaN": np.nan,
+            "None": np.nan,
+            "none": np.nan,
+            "NaT": np.nan,
+            "nat": np.nan,
+            "<NA>": np.nan,
+        })
+        texto = texto.str.replace("\u00a0", "", regex=False).str.replace(" ", "", regex=False)
+
+        preenchidos = texto.notna()
+        total_preenchido = int(preenchidos.sum())
+        if total_preenchido == 0:
+            continue
+
+        candidato_direto = pd.to_numeric(texto, errors="coerce")
+        candidato_ptbr = pd.to_numeric(
+            texto.str.replace(".", "", regex=False).str.replace(",", ".", regex=False),
+            errors="coerce",
+        )
+        candidato_enus = pd.to_numeric(
+            texto.str.replace(",", "", regex=False),
+            errors="coerce",
+        )
+
+        candidatos = [candidato_direto, candidato_ptbr, candidato_enus]
+        melhor = max(candidatos, key=lambda s: int(s[preenchidos].notna().sum()))
+        validos = int(melhor[preenchidos].notna().sum())
+        proporcao = validos / total_preenchido if total_preenchido else 0.0
+        if proporcao < proporcao_minima:
+            continue
+
+        # Evita converter identificadores com zeros à esquerda (ex.: 000123).
+        texto_preenchido = texto[preenchidos]
+        zero_esquerda = texto_preenchido.str.match(r"^0\d+$").all()
+        tamanho_constante = texto_preenchido.str.len().nunique() == 1
+        if zero_esquerda and tamanho_constante:
+            continue
+
+        df_saida[col] = melhor
+
+    return df_saida
+
+
 def carregar_arquivo(arquivo, nome_aba=None):
     """
     Carrega arquivo Excel ou CSV e retorna DataFrame.
@@ -125,6 +194,10 @@ def carregar_arquivo(arquivo, nome_aba=None):
         else:
             return None, "Formato de arquivo não suportado.", False
 
+        # Normaliza colunas textuais que representam números para evitar
+        # perda de tipagem em detecções/seleções e exportações.
+        df = _normalizar_colunas_numericas_texto(df)
+
         # Reinicia índice começando em 1
         df = df.reset_index(drop=True)
         df.index = df.index + 1
@@ -708,8 +781,11 @@ def detectar_dicotomicas(df, colunas):
     """
     dicotomicas = []
     for col in colunas:
-        valores = set(df[col].dropna().unique())
-        if valores.issubset({0, 1, 0.0, 1.0}):
+        serie_num = _normalizar_serie_numerica_classificacao(df[col]).dropna()
+        if serie_num.empty:
+            continue
+        valores = np.unique(serie_num.to_numpy(dtype=float))
+        if np.all(np.isclose(valores, 0.0) | np.isclose(valores, 1.0)):
             dicotomicas.append(col)
     return dicotomicas
 
@@ -723,19 +799,18 @@ def detectar_codigo_alocado(df, colunas):
     """
     resultado = []
     for col in colunas:
-        valores = df[col].dropna().unique()
-        valores_set = set(valores)
+        serie_num = _normalizar_serie_numerica_classificacao(df[col]).dropna()
+        if serie_num.empty:
+            continue
+        valores = np.unique(serie_num.to_numpy(dtype=float))
         # Pelo menos 3 valores distintos
-        if len(valores_set) < 3:
+        if len(valores) < 3:
             continue
         # Todos devem ser inteiros
-        try:
-            if not all(float(v) == int(float(v)) for v in valores):
-                continue
-        except (ValueError, TypeError):
+        if not np.all(np.isclose(valores, np.round(valores))):
             continue
         # Nenhum valor zero
-        if any(float(v) == 0 for v in valores):
+        if np.any(np.isclose(valores, 0.0)):
             continue
         resultado.append(col)
     return resultado
@@ -749,22 +824,67 @@ def detectar_percentuais(df, colunas):
     """
     resultado = []
     for col in colunas:
-        valores = df[col].dropna().unique()
+        serie_num = _normalizar_serie_numerica_classificacao(df[col]).dropna()
+        if serie_num.empty:
+            continue
+        valores = np.unique(serie_num.to_numpy(dtype=float))
         if len(valores) < 2:
             continue
         # Todos devem estar entre 0 e 1
-        try:
-            if not all(0 <= float(v) <= 1 for v in valores):
-                continue
-        except (ValueError, TypeError):
+        if not np.all((valores >= -1e-9) & (valores <= 1.0 + 1e-9)):
             continue
         # Não pode ser dicotômica pura (só {0,1})
-        if set(valores).issubset({0, 1, 0.0, 1.0}):
+        if np.all(np.isclose(valores, 0.0) | np.isclose(valores, 1.0)):
             continue
         resultado.append(col)
     return resultado
 
 
+def _normalizar_serie_numerica_classificacao(serie):
+    """
+    Converte série para numérico com tolerância a texto numérico.
+    Suporta formatos com vírgula decimal (pt-BR) e ignora tokens vazios.
+    """
+    if pd.api.types.is_numeric_dtype(serie):
+        return pd.to_numeric(serie, errors='coerce')
+
+    texto = serie.astype(str).str.strip().replace({
+        "": np.nan,
+        "nan": np.nan,
+        "NaN": np.nan,
+        "None": np.nan,
+        "none": np.nan,
+        "NaT": np.nan,
+        "nat": np.nan,
+        "<NA>": np.nan,
+    })
+    texto = texto.str.replace("\u00a0", "", regex=False).str.replace(" ", "", regex=False)
+    texto_sem_percentual = texto.str.replace("%", "", regex=False)
+
+    # 1) Parse padrão (ex.: 0.25, 1000)
+    direto = pd.to_numeric(texto_sem_percentual, errors='coerce')
+    melhor = direto
+    melhor_validos = int(direto.notna().sum())
+
+    # 2) Parse pt-BR (ex.: 1.234,56 -> 1234.56 | 0,25 -> 0.25)
+    pt_br = pd.to_numeric(
+        texto_sem_percentual.str.replace('.', '', regex=False).str.replace(',', '.', regex=False),
+        errors='coerce',
+    )
+    validos_pt_br = int(pt_br.notna().sum())
+    if validos_pt_br > melhor_validos:
+        melhor = pt_br
+        melhor_validos = validos_pt_br
+
+    # 3) Parse com vírgula de milhar (ex.: 1,234.56 -> 1234.56)
+    en_us = pd.to_numeric(texto_sem_percentual.str.replace(',', '', regex=False), errors='coerce')
+    validos_en_us = int(en_us.notna().sum())
+    if validos_en_us > melhor_validos:
+        melhor = en_us
+
+    return melhor
+
+
 # ============================================================
 # VERIFICAÇÃO DE MULTICOLINEARIDADE
 # ============================================================

backend/app/services/elaboracao_service.py

@@ -132,6 +132,48 @@ def _parse_serie_datas_texto_segura(serie_texto: pd.Series) -> pd.Series:
     return pd.to_datetime(serie_texto, errors="coerce", dayfirst=True)
 
 
+def _normalizar_serie_texto(serie: pd.Series) -> pd.Series:
+    texto = serie.astype(str).str.replace("\u00a0", " ", regex=False).str.strip()
+    return texto.replace(
+        {
+            "": np.nan,
+            "nan": np.nan,
+            "NaN": np.nan,
+            "None": np.nan,
+            "none": np.nan,
+            "NaT": np.nan,
+            "nat": np.nan,
+            "<NA>": np.nan,
+        }
+    )
+
+
+def _normalizar_serie_numerica_data(serie: pd.Series) -> pd.Series:
+    texto = _normalizar_serie_texto(serie)
+    texto = texto.str.replace(" ", "", regex=False)
+    texto_sem_percentual = texto.str.replace("%", "", regex=False)
+
+    direto = pd.to_numeric(texto_sem_percentual, errors="coerce")
+    melhor = direto
+    melhor_validos = int(direto.notna().sum())
+
+    pt_br = pd.to_numeric(
+        texto_sem_percentual.str.replace(".", "", regex=False).str.replace(",", ".", regex=False),
+        errors="coerce",
+    )
+    validos_pt_br = int(pt_br.notna().sum())
+    if validos_pt_br > melhor_validos:
+        melhor = pt_br
+        melhor_validos = validos_pt_br
+
+    en_us = pd.to_numeric(texto_sem_percentual.str.replace(",", "", regex=False), errors="coerce")
+    validos_en_us = int(en_us.notna().sum())
+    if validos_en_us > melhor_validos:
+        melhor = en_us
+
+    return melhor
+
+
 def list_avaliadores() -> list[dict[str, Any]]:
     global _AVALIADORES_CACHE
     if _AVALIADORES_CACHE is not None:
@@ -521,7 +563,7 @@ def _converter_coluna_para_datas(
 ) -> pd.Series:
     serie_base = serie.copy()
     if pd.api.types.is_object_dtype(serie_base) or pd.api.types.is_string_dtype(serie_base):
-        serie_base = serie_base.astype(str).str.strip().replace("", np.nan)
+        serie_base = _normalizar_serie_texto(serie_base)
 
     mascara_preenchida = serie_base.notna()
     total_preenchido = int(mascara_preenchida.sum())
@@ -547,7 +589,23 @@ def _converter_coluna_para_datas(
             )
         datas = pd.to_datetime(serie_num, unit="D", origin="1899-12-30", errors="coerce")
     else:
-        datas = _parse_serie_datas_texto_segura(serie_base)
+        datas_texto = _parse_serie_datas_texto_segura(serie_base)
+
+        # Também tenta serial Excel quando a coluna veio como texto numérico.
+        serie_num = _normalizar_serie_numerica_data(serie_base)
+        valores_validos = serie_num[mascara_preenchida].dropna()
+        if not valores_validos.empty:
+            proporcao_excel = float(valores_validos.between(20000, 80000).mean())
+            if proporcao_excel >= proporcao_excel_minima:
+                datas_excel = pd.to_datetime(serie_num, unit="D", origin="1899-12-30", errors="coerce")
+            else:
+                datas_excel = pd.Series(pd.NaT, index=serie_base.index, dtype="datetime64[ns]")
+        else:
+            datas_excel = pd.Series(pd.NaT, index=serie_base.index, dtype="datetime64[ns]")
+
+        validas_texto = int(datas_texto[mascara_preenchida].notna().sum())
+        validas_excel = int(datas_excel[mascara_preenchida].notna().sum())
+        datas = datas_excel if validas_excel > validas_texto else datas_texto
 
     datas_validas = datas[mascara_preenchida].dropna()
     proporcao = len(datas_validas) / total_preenchido if total_preenchido else 0.0
@@ -566,14 +624,23 @@ def _converter_coluna_para_datas(
 def _sugerir_coluna_data_mercado(df: pd.DataFrame | None) -> str | None:
     if df is None or df.empty:
         return None
-    for coluna in df.columns:
-        nome = str(coluna)
+
+    # Prioriza nomes de coluna com indicativo de data para reduzir falsos positivos.
+    candidatas = sorted(
+        [str(coluna) for coluna in df.columns],
+        key=lambda nome: (
+            0 if re.search(r"(^|[^a-z0-9])(data|date|dt)($|[^a-z0-9])", nome.strip().lower()) else 1,
+            nome.lower(),
+        ),
+    )
+
+    for nome in candidatas:
         try:
             _converter_coluna_para_datas(
-                df[coluna],
+                df[nome],
                 nome,
-                proporcao_minima=1.0,
-                proporcao_excel_minima=1.0,
+                proporcao_minima=0.6,
+                proporcao_excel_minima=0.6,
             )
             return nome
         except HTTPException:

frontend/src/components/ElaboracaoTab.jsx

@@ -50,7 +50,7 @@ const ELABORACAO_SECOES_NAV = [
   { step: '10', title: 'Gráficos de Dispersão das Variáveis Independentes' },
   { step: '11', title: 'Transformações Sugeridas' },
   { step: '12', title: 'Aplicação das Transformações' },
-  { step: '13', title: 'Visualizar Mapa dos Dados de Mercado' },
+  { step: '13', title: 'Gráficos de Dispersão com Transformações e Resíduos' },
   { step: '14', title: 'Diagnóstico de Modelo' },
   { step: '15', title: 'Gráficos de Diagnóstico do Modelo' },
   { step: '16', title: 'Analisar Resíduos' },
@@ -1289,6 +1289,8 @@ export default function ElaboracaoTab({ sessionId }) {
     ),
   )
   const baseCarregada = Boolean(dados)
+  const hasSelection = Boolean(selection)
+  const hasFit = Boolean(fit)
   const renderedSectionStepsSet = useMemo(() => new Set(renderedSectionSteps), [renderedSectionSteps])
   const visibleSectionStepsSet = useMemo(() => new Set(visibleSectionSteps), [visibleSectionSteps])
 
@@ -1448,7 +1450,7 @@ export default function ElaboracaoTab({ sessionId }) {
       }
       observer.disconnect()
     }
-  }, [sectionsMountKey, baseCarregada])
+  }, [sectionsMountKey, baseCarregada, hasSelection, hasFit])
 
   useEffect(() => {
     if (typeof window === 'undefined') return undefined
@@ -1874,7 +1876,6 @@ export default function ElaboracaoTab({ sessionId }) {
       setManualTransformAppliedSnapshot(buildTransformacoesSnapshot('(x)', {}))
       setOutliersAnteriores([])
       setIteracao(1)
-      setColunaDataMercadoSugerida('')
       setColunaDataMercado('')
       setColunaDataMercadoAplicada('')
       setPeriodoDadosMercado(null)
@@ -3047,6 +3048,24 @@ export default function ElaboracaoTab({ sessionId }) {
     downloadBlob(blob, `${sanitizeFileName(fileNameBase, 'tabela')}.csv`)
   }
 
+  async function onDownloadBaseOriginalCsv() {
+    if (!sessionId) {
+      onDownloadTableCsv(dados, 'secao4_dados_mercado')
+      return
+    }
+
+    setDownloadingAssets(true)
+    setError('')
+    try {
+      const blob = await api.exportBase(sessionId, false)
+      downloadBlob(blob, 'base_original.csv')
+    } catch (err) {
+      setError(err.message || 'Falha ao baixar base original.')
+    } finally {
+      setDownloadingAssets(false)
+    }
+  }
+
   async function onDownloadTablesCsvBatch(items) {
     const validItems = (items || []).filter((item) => item?.table)
     if (validItems.length === 0) {
@@ -3303,7 +3322,10 @@ export default function ElaboracaoTab({ sessionId }) {
 
     const offsetTopo = 96
     const alvo = Math.max(0, window.scrollY + secao.getBoundingClientRect().top - offsetTopo)
-    window.scrollTo({ top: alvo, behavior: 'smooth' })
+    const deslocamento = Math.abs(alvo - window.scrollY)
+    if (deslocamento <= 2) return
+    const behavior = deslocamento < 520 ? 'auto' : 'smooth'
+    window.scrollTo({ top: alvo, behavior })
   }
 
   return (
@@ -3916,8 +3938,10 @@ export default function ElaboracaoTab({ sessionId }) {
                 <button
                   type="button"
                   className="btn-download-subtle"
-                  onClick={() => onDownloadTableCsv(dados, 'secao4_dados_mercado')}
-                  disabled={loading || downloadingAssets || !dados}
+                  onClick={() => {
+                    void onDownloadBaseOriginalCsv()
+                  }}
+                  disabled={loading || downloadingAssets || (!sessionId && !dados)}
                 >
                   Fazer download
                 </button>
@@ -4558,7 +4582,7 @@ export default function ElaboracaoTab({ sessionId }) {
 
       {fit ? (
         <>
-          <SectionBlock step="13" title="Visualizar Mapa dos Dados de Mercado" subtitle="Escolha livre dos eixos para análise gráfica do modelo.">
+          <SectionBlock step="13" title="Gráficos de Dispersão com Transformações e Resíduos" subtitle="Escolha livre dos eixos para análise gráfica do modelo.">
             {secao13ModoPng ? (
               <div className="section-disclaimer-warning">
                 Modo PNG automático para mais de {secao13PngPayload?.limiar || fit?.grafico_dispersao_modelo_limiar_png || 1500} pontos. Ao final da seção, podem ser gerados individualmente os gráficos interativos.

frontend/src/components/RepositorioTab.jsx

@@ -258,7 +258,7 @@ export default function RepositorioTab({ authUser, sessionId }) {
               <h3>{modeloAbertoMeta?.nome || 'Modelo'}</h3>
               <p>Visualização do modelo do repositório</p>
             </div>
-            <button type="button" className="model-source-back-btn" onClick={onVoltarRepositorio} disabled={modeloAbertoLoading}>
+            <button type="button" className="model-source-back-btn model-source-back-btn-danger" onClick={onVoltarRepositorio} disabled={modeloAbertoLoading}>
               Voltar ao repositório
             </button>
           </div>

frontend/src/styles.css

@@ -1871,9 +1871,25 @@ button.pesquisa-coluna-remove:hover {
   padding: 14px;
   display: grid;
   gap: 12px;
+  min-width: 0;
   box-shadow: var(--shadow-sm);
 }
 
+.pesquisa-opened-model-view .inner-tab-panel {
+  min-width: 0;
+}
+
+.pesquisa-opened-model-view .table-wrapper {
+  width: 100%;
+  min-width: 0;
+  overflow-x: auto;
+}
+
+.pesquisa-opened-model-view .table-wrapper table {
+  width: max-content;
+  min-width: 100%;
+}
+
 .pesquisa-opened-model-head {
   display: flex;
   justify-content: space-between;