feat: Готовый проект

Dockerfile

@@ -8,7 +8,8 @@ RUN apt-get update && apt-get install -y \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
+COPY src/requirements.txt ./
+COPY src/ ./src/
 
 RUN pip3 install -r requirements.txt
 

streamlit_preprocess_app.py

@@ -1,833 +0,0 @@
-# streamlit_preprocess_app.py
-"""
-Streamlit-приложение: предобработка (3.2), описательный анализ (3.3), тесты стационарности (3.4), генерация лагов/скользящих признаков (3.5), ACF/PACF (3.6), декомпозиция (3.7) и экспорт/веб-интерфейс (3.8).
-
-Запуск:
-  pip install pandas numpy streamlit pytz plotly statsmodels scikit-learn
-  streamlit run streamlit_preprocess_app.py
-
-Файл создан для Дмитрия: сохраняет результаты в st.session_state, чтобы при смене виджетов
-результаты не пропадали.
-"""
-import os
-import io
-import base64
-from typing import Optional, List, Tuple, Dict
-
-import numpy as np
-import pandas as pd
-import pytz
-import streamlit as st
-import plotly.express as px
-import plotly.graph_objects as go
-import matplotlib.pyplot as plt
-from statsmodels.tsa.stattools import adfuller, kpss, acf as sm_acf, pacf as sm_pacf
-from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
-from statsmodels.tsa.seasonal import seasonal_decompose
-from statsmodels.stats.outliers_influence import variance_inflation_factor
-from statsmodels.tools import add_constant
-
-st.set_page_config(page_title="TS Preprocess & EDA (3.2–3.8)", layout="wide")
-MOSCOW = pytz.timezone("Europe/Moscow")
-
-
-# ---------------- Utilities ----------------
-def detect_date_column(df: pd.DataFrame) -> Optional[str]:
-    candidates = [c for c in df.columns if any(k in c.lower() for k in ("date", "time", "timestamp", "dt", "day"))]
-    if candidates:
-        pref = [c for c in candidates if 'date' in c.lower()]
-        return pref[0] if pref else candidates[0]
-    scores = {}
-    for c in df.columns:
-        parsed = pd.to_datetime(df[c], errors='coerce', dayfirst=True, infer_datetime_format=True)
-        scores[c] = parsed.notna().mean()
-    best, score = max(scores.items(), key=lambda x: x[1])
-    return best if score > 0.5 else None
-
-
-def try_parse_dates(series: pd.Series) -> pd.Series:
-    s = series.astype(str).replace('nan', pd.NA)
-    parsed = pd.to_datetime(s, errors='coerce', infer_datetime_format=True)
-    parsed = parsed.fillna(pd.to_datetime(s, format='%d.%m.%Y', errors='coerce'))
-    parsed = parsed.fillna(pd.to_datetime(s, format='%Y-%m-%d', errors='coerce'))
-    return parsed
-
-
-def localize_to_moscow(ts: pd.Series, assume_tz: str = 'local') -> pd.Series:
-    ts = pd.to_datetime(ts, errors='coerce')
-    if ts.dt.tz is None:
-        if assume_tz == 'utc':
-            ts = ts.dt.tz_localize('UTC').dt.tz_convert('Europe/Moscow')
-        elif assume_tz == 'local':
-            ts = ts.dt.tz_localize('Europe/Moscow')
-        else:
-            pass
-    else:
-        ts = ts.dt.tz_convert('Europe/Moscow')
-    return ts
-
-
-def detect_outliers_iqr(col: pd.Series) -> pd.Series:
-    q1 = col.quantile(0.25)
-    q3 = col.quantile(0.75)
-    iqr = q3 - q1
-    lo = q1 - 1.5 * iqr
-    hi = q3 + 1.5 * iqr
-    return (col < lo) | (col > hi)
-
-
-def winsorize_series(col: pd.Series, lower_q: float = 0.01, upper_q: float = 0.99) -> pd.Series:
-    low = col.quantile(lower_q)
-    high = col.quantile(upper_q)
-    return col.clip(lower=low, upper=high)
-
-
-# ---------------- Preprocessing (3.2) ----------------
-def preprocess_timeseries(
-    df: pd.DataFrame,
-    date_col: str,
-    tz_assume: str = 'local',
-    numeric_missing_strategy: str = 'interpolate',
-    cat_missing_strategy: str = 'mode',
-    outlier_strategy: str = 'interpolate',
-    resample_freq: Optional[str] = None,
-) -> Tuple[pd.DataFrame, Dict]:
-    info: Dict = {}
-    df2 = df.copy()
-    parsed = try_parse_dates(df2[date_col])
-    info['parse_success'] = float(parsed.notna().mean())
-    df2['timestamp'] = parsed
-    df2['timestamp'] = localize_to_moscow(df2['timestamp'], assume_tz=tz_assume)
-    before = len(df2)
-    df2 = df2.dropna(subset=['timestamp']).reset_index(drop=True)
-    info['dropped_no_timestamp'] = before - len(df2)
-    df2 = df2.sort_values('timestamp').drop_duplicates(subset=['timestamp']).reset_index(drop=True)
-
-    num_cols = df2.select_dtypes(include=[np.number]).columns.tolist()
-    cat_cols = [c for c in df2.columns if c not in num_cols and c != 'timestamp' and c != date_col]
-    info['num_cols'] = num_cols
-    info['cat_cols'] = cat_cols
-
-    info['missing_before'] = df2[num_cols].isna().sum().to_dict()
-
-    if numeric_missing_strategy == 'drop':
-        df2 = df2.dropna(subset=num_cols).reset_index(drop=True)
-    elif numeric_missing_strategy == 'interpolate':
-        df2 = df2.set_index('timestamp')
-        df2[num_cols] = df2[num_cols].interpolate(method='time', limit_direction='both')
-        df2 = df2.reset_index()
-    elif numeric_missing_strategy == 'rolling':
-        for c in num_cols:
-            df2[c] = df2[c].fillna(df2[c].rolling(window=7, min_periods=1).mean())
-    else:
-        raise ValueError('unknown numeric_missing_strategy')
-
-    for c in cat_cols:
-        if cat_missing_strategy == 'mode':
-            mode = df2[c].mode()
-            fill = mode[0] if not mode.empty else 'unknown'
-            df2[c] = df2[c].fillna(fill)
-        else:
-            df2[c] = df2[c].fillna('unknown')
-
-    info['missing_after'] = df2[num_cols].isna().sum().to_dict()
-
-    outlier_summary = []
-    for c in num_cols:
-        col = df2[c]
-        iqr_mask = detect_outliers_iqr(col)
-        outlier_summary.append({'column': c, 'iqr_count': int(iqr_mask.sum())})
-    info['outlier_summary'] = outlier_summary
-
-    if outlier_strategy == 'mark':
-        pass
-    elif outlier_strategy == 'interpolate':
-        df2 = df2.set_index('timestamp')
-        for c in num_cols:
-            mask = detect_outliers_iqr(df2[c])
-            df2.loc[mask, c] = np.nan
-        df2[num_cols] = df2[num_cols].interpolate(method='time', limit_direction='both')
-        df2 = df2.reset_index()
-    elif outlier_strategy == 'winsorize':
-        for c in num_cols:
-            df2[c] = winsorize_series(df2[c])
-    elif outlier_strategy == 'drop':
-        for c in num_cols:
-            mask = detect_outliers_iqr(df2[c])
-            df2 = df2.loc[~mask].reset_index(drop=True)
-    else:
-        raise ValueError('unknown outlier_strategy')
-
-    if resample_freq is not None:
-        df2 = df2.set_index('timestamp')
-        agg = {}
-        for c in num_cols:
-            lname = c.lower()
-            if any(k in lname for k in ('case', 'count', 'death', 'new', 'confirmed', 'positive', 'tests')):
-                agg[c] = 'sum'
-            else:
-                agg[c] = 'mean'
-        res = df2.resample(resample_freq).agg(agg)
-        for c in cat_cols:
-            res[c] = df2[c].resample(resample_freq).first()
-        res = res.reset_index()
-        df2 = res
-
-    if 'timestamp' in df2.columns:
-        ts = pd.to_datetime(df2['timestamp'])
-        if ts.dt.tz is None:
-            df2['timestamp'] = ts.dt.tz_localize('Europe/Moscow')
-        else:
-            df2['timestamp'] = ts.dt.tz_convert('Europe/Moscow')
-
-    info['final_shape'] = df2.shape
-    return df2, info
-
-
-# ---------------- Descriptive (3.3) ----------------
-def descriptive_statistics(df: pd.DataFrame, numeric_cols: List[str]) -> pd.DataFrame:
-    rows = []
-    for c in numeric_cols:
-        s = df[c].dropna()
-        rows.append({
-            'column': c,
-            'count': int(s.count()),
-            'mean': float(s.mean()) if not s.empty else None,
-            'median': float(s.median()) if not s.empty else None,
-            'std': float(s.std()) if not s.empty else None,
-            'min': float(s.min()) if not s.empty else None,
-            'q1': float(s.quantile(0.25)) if not s.empty else None,
-            'q3': float(s.quantile(0.75)) if not s.empty else None,
-            'max': float(s.max()) if not s.empty else None,
-            'skew': float(s.skew()) if not s.empty else None,
-            'kurtosis': float(s.kurtosis()) if not s.empty else None,
-            'missing_pct': float(df[c].isna().mean())
-        })
-    return pd.DataFrame(rows).set_index('column')
-
-
-# ---------------- Stationarity (3.4) helpers ----------------
-def run_adf(series: pd.Series) -> Dict:
-    try:
-        res = adfuller(series.dropna().values, autolag='AIC')
-        return {'statistic': res[0], 'pvalue': res[1], 'usedlag': res[2], 'nobs': res[3]}
-    except Exception as e:
-        return {'error': str(e)}
-
-
-def run_kpss(series: pd.Series) -> Dict:
-    try:
-        res = kpss(series.dropna().values, nlags='auto')
-        return {'statistic': res[0], 'pvalue': res[1], 'nlags': res[2]}
-    except Exception as e:
-        return {'error': str(e)}
-
-
-# ---------------- Lag & Rolling (3.5) ----------------
-def create_lags_and_rolls(df: pd.DataFrame, target: str, lags: List[int], roll_windows: List[int], extra_features: List[str] = None) -> pd.DataFrame:
-    df2 = df.copy().set_index('timestamp')
-    df2 = df2.sort_index()
-    for l in lags:
-        df2[f'{target}_lag_{l}'] = df2[target].shift(l)
-    if extra_features:
-        for feat in extra_features:
-            for l in lags:
-                df2[f'{feat}_lag_{l}'] = df2[feat].shift(l)
-    for w in roll_windows:
-        df2[f'{target}_roll_mean_{w}'] = df2[target].rolling(window=w, min_periods=1).mean()
-        df2[f'{target}_roll_std_{w}'] = df2[target].rolling(window=w, min_periods=1).std()
-    return df2.reset_index()
-
-
-def compute_lag_correlations(df: pd.DataFrame, target: str, lags: List[int]) -> pd.DataFrame:
-    cols = [f'{target}_lag_{l}' for l in lags if f'{target}_lag_{l}' in df.columns]
-    corr_rows = []
-    for c in cols:
-        corr = df[[target, c]].dropna().corr().iloc[0, 1]
-        corr_rows.append({'lag_col': c, 'corr_with_target': float(corr) if pd.notna(corr) else None})
-    return pd.DataFrame(corr_rows).set_index('lag_col')
-
-
-def compute_vif(df: pd.DataFrame, features: List[str]) -> pd.DataFrame:
-    X = df[features].dropna()
-    if X.shape[0] == 0:
-        return pd.DataFrame({'feature': features, 'VIF': [None] * len(features)}).set_index('feature')
-    X_const = add_constant(X)
-    vif_vals = []
-    for i, col in enumerate(X.columns):
-        try:
-            v = variance_inflation_factor(X_const.values, i + 1)
-        except Exception:
-            v = np.nan
-        vif_vals.append({'feature': col, 'VIF': float(v) if pd.notna(v) else None})
-    return pd.DataFrame(vif_vals).set_index('feature')
-
-
-# ---------------- ACF/PACF helpers (3.6) ----------------
-def get_acf_pacf_with_conf(series: pd.Series, nlags: int = 40, alpha: float = 0.05):
-    acf_vals, acf_confint = sm_acf(series.dropna().values, nlags=nlags, alpha=alpha)
-    pacf_vals, pacf_confint = sm_pacf(series.dropna().values, nlags=nlags, alpha=alpha)
-    return acf_vals, acf_confint, pacf_vals, pacf_confint
-
-
-def significant_lags_from_conf(vals: np.ndarray, confint: np.ndarray) -> List[int]:
-    sig = []
-    for i in range(1, len(vals)):
-        lower, upper = confint[i]
-        v = vals[i]
-        if (v < lower) or (v > upper):
-            sig.append(i)
-    return sig
-
-
-def plotly_acf_pacf(acf_vals, acf_conf, pacf_vals, pacf_conf, max_lag, title_prefix=''):
-    # build ACF bar + conf intervals
-    lags = list(range(len(acf_vals)))[: max_lag + 1]
-    acf_fig = go.Figure()
-    acf_fig.add_trace(go.Bar(x=lags, y=acf_vals[:len(lags)], name='ACF'))
-    # conf intervals as lines
-    if acf_conf is not None and len(acf_conf) >= len(lags):
-        lower = [acf_conf[i][0] for i in lags]
-        upper = [acf_conf[i][1] for i in lags]
-        acf_fig.add_trace(go.Scatter(x=lags, y=upper, mode='lines', line=dict(width=1), name='conf_upper'))
-        acf_fig.add_trace(go.Scatter(x=lags, y=lower, mode='lines', line=dict(width=1), name='conf_lower'))
-    acf_fig.update_layout(title=f'{title_prefix} ACF', xaxis_title='lag')
-
-    lags_p = list(range(len(pacf_vals)))[: max_lag + 1]
-    pacf_fig = go.Figure()
-    pacf_fig.add_trace(go.Bar(x=lags_p, y=pacf_vals[:len(lags_p)], name='PACF'))
-    if pacf_conf is not None and len(pacf_conf) >= len(lags_p):
-        lowerp = [pacf_conf[i][0] for i in lags_p]
-        upperp = [pacf_conf[i][1] for i in lags_p]
-        pacf_fig.add_trace(go.Scatter(x=lags_p, y=upperp, mode='lines', line=dict(width=1), name='conf_upper'))
-        pacf_fig.add_trace(go.Scatter(x=lags_p, y=lowerp, mode='lines', line=dict(width=1), name='conf_lower'))
-    pacf_fig.update_layout(title=f'{title_prefix} PACF', xaxis_title='lag')
-    return acf_fig, pacf_fig
-
-
-# ---------------- Report generation (3.8 helpers) ----------------
-def generate_html_report(
-    df: pd.DataFrame,
-    target: str,
-    features: List[str],
-    params: Dict,
-    figs: Dict[str, any],
-    tables: Dict[str, pd.DataFrame]
-) -> str:
-    parts = []
-    parts.append(f"<h1>Отчёт по временным рядам — target: {target}</h1>")
-    parts.append(f"<p>Параметры: {params}</p>")
-
-    # include time series fig
-    if 'series' in figs:
-        parts.append('<h2>Временной ряд</h2>')
-        parts.append(figs['series'].to_html(full_html=False, include_plotlyjs='cdn'))
-
-    if 'decomp' in figs:
-        parts.append('<h2>Декомпозиция</h2>')
-        parts.append(figs['decomp_observed'].to_html(full_html=False, include_plotlyjs='cdn'))
-        parts.append(figs['decomp_trend'].to_html(full_html=False, include_plotlyjs='cdn'))
-        parts.append(figs['decomp_seasonal'].to_html(full_html=False, include_plotlyjs='cdn'))
-        parts.append(figs['decomp_resid'].to_html(full_html=False, include_plotlyjs='cdn'))
-
-    if 'corr' in figs:
-        parts.append('<h2>Матрица корреляций</h2>')
-        parts.append(figs['corr'].to_html(full_html=False, include_plotlyjs='cdn'))
-
-    if 'acf' in figs and 'pacf' in figs:
-        parts.append('<h2>ACF / PACF</h2>')
-        parts.append(figs['acf'].to_html(full_html=False, include_plotlyjs='cdn'))
-        parts.append(figs['pacf'].to_html(full_html=False, include_plotlyjs='cdn'))
-
-    # tables
-    for name, table in tables.items():
-        parts.append(f'<h3>{name}</h3>')
-        parts.append(table.to_html(classes="table table-striped", index=True))
-
-    html = '<html><head><meta charset="utf-8"></head><body>' + ''.join(parts) + '</body></html>'
-    return html
-
-
-# ---------------- Streamlit UI ----------------
-st.title("Временные ряды — предобработка, EDA, стационарность, лаги, ACF/PACF, декомпозиция и экспорт (3.2–3.8)")
-
-# Sidebar
-st.sidebar.header("Настройки")
-uploaded_file = st.sidebar.file_uploader("Загрузите CSV/Parquet", type=['csv', 'parquet'])
-
-# small built-in example option (uses local file if present)
-sample_option = None
-if os.path.exists('russia_covid_dataset.csv'):
-    sample_option = 'russia_covid_dataset.csv'
-sample_choice = st.sidebar.selectbox('Или выбрать предзагруженный пример', options=[None, sample_option] if sample_option else [None])
-
-tz_assume = st.sidebar.selectbox("Как трактовать tz-naive метки?",
-                                 options=['local', 'utc', 'keep'], index=0,
-                                 format_func=lambda x: {'local': 'локально (Europe/Moscow)', 'utc': 'UTC->Moscow', 'keep': 'не трогать'}[x])
-numeric_missing_strategy = st.sidebar.selectbox("Заполнение пропусков (числ.)", options=['interpolate', 'drop', 'rolling'], index=0)
-cat_missing_strategy = st.sidebar.selectbox("Заполнение пропусков (категор.)", options=['mode', 'unknown'], index=0)
-outlier_strategy = st.sidebar.selectbox("Обработка выбросов", options=['interpolate', 'winsorize', 'drop', 'mark'], index=0)
-resample_freq = st.sidebar.selectbox("Ресемплить к частоте (если нужно)", options=[None, 'D', 'W', 'M'], index=1)
-
-# load dataset and persist
-if 'df_in' not in st.session_state:
-    st.session_state['df_in'] = None
-
-if uploaded_file is not None:
-    try:
-        if uploaded_file.name.endswith('.parquet'):
-            df_in = pd.read_parquet(uploaded_file)
-        else:
-            df_in = pd.read_csv(uploaded_file, low_memory=False)
-        st.session_state['df_in'] = df_in
-        st.success(f"Загружен файл: {uploaded_file.name} ({df_in.shape[0]}×{df_in.shape[1]})")
-    except Exception as e:
-        st.error(f"Ошибка загрузки: {e}")
-        st.stop()
-elif sample_choice:
-    st.session_state['df_in'] = pd.read_csv(sample_choice, low_memory=False)
-    st.info(f"Выбран пример: {sample_choice}")
-else:
-    local_path = 'russia_covid_dataset.csv'
-    if st.session_state['df_in'] is None and os.path.exists(local_path):
-        st.session_state['df_in'] = pd.read_csv(local_path, low_memory=False)
-        st.info(f"Авто-загружен локальный файл {local_path}")
-    elif st.session_state['df_in'] is None:
-        st.info("Загрузите файл или поместите russia_covid_dataset.csv в рабочую папку.")
-        st.stop()
-
-
-df_in = st.session_state['df_in']
-st.subheader("Preview входного датасета")
-st.dataframe(df_in.head(8))
-
-# detect date column
-detected = detect_date_column(df_in)
-col_for_date = st.text_input("Колонка с временной меткой", value=detected if detected else "")
-if not col_for_date:
-    st.error("Укажите колонку с временной меткой.")
-    st.stop()
-
-# Run buttons
-col1, col2 = st.columns([1, 1])
-with col1:
-    run_btn = st.button("Run Preprocessing")
-with col2:
-    force_btn = st.button("Force Recompute (пересчитать)")
-
-# session keys
-st.session_state.setdefault('preprocessed', False)
-st.session_state.setdefault('df_clean', None)
-st.session_state.setdefault('info', {})
-st.session_state.setdefault('df_lags', None)
-
-if run_btn or force_btn or (not st.session_state['preprocessed'] and st.session_state['df_clean'] is None):
-    df_clean, info = preprocess_timeseries(
-        df_in,
-        date_col=col_for_date,
-        tz_assume=tz_assume,
-        numeric_missing_strategy=numeric_missing_strategy,
-        cat_missing_strategy=cat_missing_strategy,
-        outlier_strategy=outlier_strategy,
-        resample_freq=resample_freq,
-    )
-    st.session_state['df_clean'] = df_clean
-    st.session_state['info'] = info
-    st.session_state['preprocessed'] = True
-
-# Main UI after preprocess
-if st.session_state.get('preprocessed'):
-    df_clean = st.session_state['df_clean']
-    info = st.session_state['info']
-
-    st.subheader("Финальный датасет (первые строки)")
-    st.dataframe(df_clean.head(10))
-    st.markdown(f"**Размер до/после:** {df_in.shape} → {info.get('final_shape')}")
-    st.markdown(f"**Доля распарсенных дат:** {info.get('parse_success', 0):.2%}")
-    st.markdown(f"**Удалено строк без даты:** {info.get('dropped_no_timestamp', 0)}")
-
-    st.download_button("Скачать final_dataset.csv", data=df_clean.to_csv(index=False).encode('utf-8'), file_name='final_dataset.csv', mime='text/csv')
-
-    # 3.3 Descriptive
-    st.header("Этап 3.3 — Описательная статистика и визуализация")
-    numeric_cols = df_clean.select_dtypes(include=[np.number]).columns.tolist()
-    if not numeric_cols:
-        st.warning("Нет числовых колонок для анализа.")
-    else:
-        stats_df = descriptive_statistics(df_clean, numeric_cols)
-        st.subheader("Дескриптивная статистика")
-        st.dataframe(stats_df)
-
-        st.subheader("Гистограммы / Boxplot / Pairwise")
-        sel = st.multiselect("Выбрать колонки для графиков", numeric_cols, default=numeric_cols[:3])
-        for c in sel:
-            c1, c2 = st.columns(2)
-            with c1:
-                fig = px.histogram(df_clean, x=c, nbins=60, title=f'Histogram: {c}')
-                st.plotly_chart(fig, use_container_width=True)
-            with c2:
-                figb = go.Figure()
-                figb.add_trace(go.Box(y=df_clean[c], name=c))
-                st.plotly_chart(figb, use_container_width=True)
-
-        if len(sel) >= 2:
-            st.subheader("Scatter matrix")
-            figm = px.scatter_matrix(df_clean, dimensions=sel[:6], title='Scatter matrix (часть признаков)')
-            st.plotly_chart(figm, use_container_width=True)
-
-        st.subheader("Матрица корреляций")
-        corr_method = st.selectbox("Тип корреляции", options=['pearson', 'spearman'], index=0)
-        corr = df_clean[numeric_cols].corr(method=corr_method)
-        figc = px.imshow(corr, text_auto=True, title=f'Correlation ({corr_method})')
-        st.plotly_chart(figc, use_container_width=True)
-
-    # 3.4 Stationarity
-    st.header("Этап 3.4 — Проверка на стационарность (ADF/KPSS) и визуальная диагностика")
-    if not numeric_cols:
-        st.info("Нет числовых колонок для тестов.")
-    else:
-        station_target = st.selectbox("Выберите колонку для тестов", options=numeric_cols, index=0, key='station_target')
-        window1 = st.number_input("Окно rolling mean/std (точки)", min_value=3, max_value=365, value=30)
-        s = df_clean.set_index('timestamp')[station_target].dropna()
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(x=s.index, y=s.values, name='series'))
-        roll_mean = s.rolling(window=window1, min_periods=1).mean()
-        roll_std = s.rolling(window=window1, min_periods=1).std()
-        fig.add_trace(go.Scatter(x=roll_mean.index, y=roll_mean.values, name=f'rolling_mean_{window1}'))
-        fig.update_layout(title=f'Series & rolling mean ({station_target})', height=400)
-        st.plotly_chart(fig, use_container_width=True)
-        fig2 = go.Figure()
-        fig2.add_trace(go.Scatter(x=roll_std.index, y=roll_std.values, name=f'rolling_std_{window1}'))
-        fig2.update_layout(title=f'Rolling std ({station_target})', height=300)
-        st.plotly_chart(fig2, use_container_width=True)
-
-        if st.button("Run stationarity tests"):
-            adf_res = run_adf(s)
-            kpss_res = run_kpss(s)
-            alpha = 0.05
-            adf_stationary = ('pvalue' in adf_res) and (adf_res['pvalue'] < alpha)
-            kpss_stationary = ('pvalue' in kpss_res) and (kpss_res['pvalue'] > alpha)
-            st.subheader("Результаты тестов")
-            st.write("ADF:", adf_res)
-            st.write("KPSS:", kpss_res)
-            st.markdown(f"Интерпретация при α={alpha}:  ")
-            st.write(f"- ADF говорит, что ряд {'стационарен' if adf_stationary else 'НЕ стационарен'} (p={adf_res.get('pvalue','?')})")
-            st.write(f"- KPSS говорит, что ряд {'стационарен' if kpss_stationary else 'НЕ стационарен'} (p={kpss_res.get('pvalue','?')})")
-            if adf_stationary and kpss_stationary:
-                st.success("Оба теста согласны: ряд, скорее всего, стационарен.")
-            elif (not adf_stationary) and (not kpss_stationary):
-                st.warning("Оба теста указывают на нестационарность → рекомендуем дифференцирование / детренд / лог-трансформацию.")
-            else:
-                st.info("Тесты противоречат друг другу — смотрите графики rolling mean/std и пробуйте трансформации (log/diff).")
-
-        st.subheader("Применить дифференцирование и повторить тесты")
-        diff_order = st.number_input("Порядок дифференцирования (целое >=1)", min_value=1, max_value=5, value=1, step=1)
-        if st.button("Apply diff & Re-test"):
-            s_diff = s.diff(periods=diff_order).dropna()
-            adf_res = run_adf(s_diff)
-            kpss_res = run_kpss(s_diff)
-            st.write(f"Результаты для {diff_order}-го диффа:")
-            st.write("ADF:", adf_res)
-            st.write("KPSS:", kpss_res)
-            figd = px.line(x=s_diff.index, y=s_diff.values, title=f'Differenced series (order={diff_order})')
-            st.plotly_chart(figd, use_container_width=True)
-            if st.checkbox("Сохранить дифференцированный ряд в session (переопределит final_dataset)", value=False):
-                df_store = df_clean.copy()
-                df_store[station_target] = df_store[station_target].diff(periods=diff_order)
-                df_store = df_store.dropna(subset=[station_target]).reset_index(drop=True)
-                st.session_state['df_clean'] = df_store
-                st.success("Дифференцированный ряд сохранён в final_dataset (session).")
-
-    # 3.5 Lag & Rolling features
-    st.header("Этап 3.5 — Создание лагов и скользящих статистик")
-    if not numeric_cols:
-        st.info("Нет числовых колонок для создания лагов.")
-    else:
-        st.subheader("Параметры генерации лагов/скользящих")
-        target_col = st.selectbox("Выберите целевую колонку (target)", options=numeric_cols, index=0, key='lag_target')
-        default_lags = st.text_input("Список лагов через запятую (напр. 1,7,30)", value='1,7,30')
-        default_rolls = st.text_input("Список окон для скользящих через запятую (напр. 7,30)", value='7,30')
-        extra_feats_raw = st.text_input("Доп. признаки для лагов (через запятую), необязательно", value='')
-
-        try:
-            lags = [int(x.strip()) for x in default_lags.split(',') if x.strip()]
-        except Exception:
-            lags = [1, 7, 30]
-        try:
-            rolls = [int(x.strip()) for x in default_rolls.split(',') if x.strip()]
-        except Exception:
-            rolls = [7, 30]
-        extra_feats = [x.strip() for x in extra_feats_raw.split(',') if x.strip()]
-        extra_feats = [f for f in extra_feats if f in df_clean.columns]
-
-        if st.button('Generate lags & rolls'):
-            df_lags = create_lags_and_rolls(df_clean, target_col, lags, rolls, extra_features=extra_feats)
-            st.session_state['df_lags'] = df_lags
-            st.success(f'Создан датасет с лагами: shape={df_lags.shape}')
-
-        if st.session_state.get('df_lags') is not None:
-            df_lags = st.session_state['df_lags']
-            st.subheader('Первые строки с лагами')
-            st.dataframe(df_lags.head(10))
-
-            st.subheader('Корреляция лагов с target')
-            corr_lags = compute_lag_correlations(df_lags, target_col, lags)
-            st.dataframe(corr_lags)
-
-            st.subheader('Heatmap корреляций (лаги + target + дополнительные фичи)')
-            lag_cols = [f'{target_col}_lag_{l}' for l in lags if f'{target_col}_lag_{l}' in df_lags.columns]
-            numeric_subset = [target_col] + lag_cols + [c for c in extra_feats if c in df_lags.select_dtypes(include=[np.number]).columns]
-            if len(numeric_subset) >= 2:
-                corr2 = df_lags[numeric_subset].corr()
-                figh = px.imshow(corr2, text_auto=True, title='Lag correlations heatmap')
-                st.plotly_chart(figh, use_container_width=True)
-
-            st.subheader('Проверка мультиколлинеарности (VIF) для признаков с лагами')
-            candidate_feats = st.multiselect('Выберите признаки для VIF (по умолчанию lag-колонки)', options=numeric_subset, default=lag_cols)
-            if candidate_feats:
-                vif_df = compute_vif(df_lags, candidate_feats)
-                st.dataframe(vif_df)
-
-            st.download_button('Скачать датасет с лагами (CSV)', data=df_lags.to_csv(index=False).encode('utf-8'), file_name='dataset_with_lags.csv', mime='text/csv')
-
-            if st.checkbox('Сохранить датасет с лагами в session (df_clean <- df_lags конвертировать)', value=False):
-                st.session_state['df_clean'] = df_lags
-                st.success('final_dataset в session заменён на датасет с лагами.')
-
-    # 3.6 ACF / PACF
-    st.header("Этап 3.6 — Анализ автокорреляции: ACF и PACF")
-    if not numeric_cols:
-        st.info('Нет числовых колонок для ACF/PACF.')
-    else:
-        acf_target = st.selectbox('Выберите колонку для ACF/PACF', options=numeric_cols, index=0, key='acf_target')
-        max_lag = st.number_input('Максимальный лаг (nlags)', min_value=10, max_value=500, value=40, step=1)
-        alpha = st.slider('Уровень значимости для доверительного интервала (alpha)', min_value=0.01, max_value=0.2, value=0.05, step=0.01)
-
-        s_acf = df_clean.set_index('timestamp')[acf_target].dropna()
-        if len(s_acf) < 2:
-            st.warning('Недостаточно наблюдений для ACF/PACF.')
-        else:
-            try:
-                acf_vals, acf_conf, pacf_vals, pacf_conf = get_acf_pacf_with_conf(s_acf, nlags=int(max_lag), alpha=float(alpha))
-            except Exception as e:
-                st.error(f'Ошибка при вычислении ACF/PACF: {e}')
-                acf_vals = pacf_vals = np.array([])
-                acf_conf = pacf_conf = np.array([])
-
-            fig_acf = plt.figure(figsize=(10, 4))
-            plot_acf(s_acf.values, lags=int(max_lag), alpha=alpha, zero=True, title=f'ACF: {acf_target}', ax=fig_acf.gca())
-            st.pyplot(fig_acf)
-
-            fig_pacf = plt.figure(figsize=(10, 4))
-            plot_pacf(s_acf.values, lags=int(max_lag), alpha=alpha, method='ywm', title=f'PACF: {acf_target}', ax=fig_pacf.gca())
-            st.pyplot(fig_pacf)
-
-            sig_acf = significant_lags_from_conf(acf_vals, acf_conf) if acf_vals.size else []
-            sig_pacf = significant_lags_from_conf(pacf_vals, pacf_conf) if pacf_vals.size else []
-
-            st.subheader('Статистически значимые лаги (по доверительным интервалам)')
-            st.write('ACF значимые лаги:', sig_acf)
-            st.write('PACF значимые лаги:', sig_pacf)
-
-            acf_rows = []
-            for i in range(min(len(acf_vals), int(max_lag) + 1)):
-                lower, upper = acf_conf[i] if acf_conf.size else (None, None)
-                acf_rows.append({'lag': i, 'acf': float(acf_vals[i]), 'conf_low': float(lower) if lower is not None else None, 'conf_high': float(upper) if upper is not None else None})
-            pacf_rows = []
-            for i in range(min(len(pacf_vals), int(max_lag) + 1)):
-                lower, upper = pacf_conf[i] if pacf_conf.size else (None, None)
-                pacf_rows.append({'lag': i, 'pacf': float(pacf_vals[i]), 'conf_low': float(lower) if lower is not None else None, 'conf_high': float(upper) if upper is not None else None})
-
-            st.subheader('ACF values (таблица)')
-            st.dataframe(pd.DataFrame(acf_rows).set_index('lag'))
-            st.subheader('PACF values (таблица)')
-            st.dataframe(pd.DataFrame(pacf_rows).set_index('lag'))
-
-            st.markdown('**Интерпретация (упрощённо):** - Резкий обрыв в PACF на лаге p → возможный порядок AR(p). - Плавное затухание в ACF → возможный порядок MA(q). - Лаги, выходящие за доверительный интервал — статистически значимы.')
-
-    # 3.7 Decomposition
-    st.header("Этап 3.7 — Декомпозиция временного ряда")
-    if not numeric_cols:
-        st.info('Нет числовых колонок для декомпозиции.')
-    else:
-        decomp_target = st.selectbox('Выберите колонку для декомпозиции', options=numeric_cols, index=0, key='decomp_target')
-        model_choice = st.radio('Модель декомпозиции', options=['additive', 'multiplicative'], index=0)
-        period_option = st.selectbox('Период сезонности (если известен)', options=['auto', '7', '30', '365', 'custom'], index=0)
-        custom_period = None
-        if period_option == 'custom':
-            custom_period = st.number_input('Введите период (целое >1)', min_value=2, value=30, step=1)
-        if period_option == 'auto':
-            inferred = None
-            try:
-                tmp = df_clean.set_index('timestamp')[decomp_target].dropna()
-                inferred_freq = pd.infer_freq(tmp.index)
-                if inferred_freq in ('D', 'B'):
-                    suggested = 7
-                elif inferred_freq == 'W':
-                    suggested = 52
-                else:
-                    suggested = None
-                inferred = suggested
-            except Exception:
-                inferred = None
-        else:
-            inferred = int(period_option) if period_option in ('7', '30', '365') else None
-        period = custom_period if custom_period is not None else inferred
-
-        st.write(f'Выбранная модель: {model_choice}. Период: {period if period is not None else "не задан (нужен для правильной декомпозиции)"}.')
-
-        if st.button('Run decomposition'):
-            s = df_clean.set_index('timestamp')[decomp_target].dropna()
-            if period is None:
-                st.error('Период не определён. Укажите период (например 7 для недельной сезонности) или используйте custom.')
-            elif len(s) < period * 2:
-                st.error(f'Недостаточно точек для надёжной декомпозиции при периоде={period}. Нужно >= 2*period наблюдений. У вас {len(s)}.')
-            else:
-                try:
-                    decomp = seasonal_decompose(s, period=int(period), model=model_choice, extrapolate_trend='freq')
-                    st.session_state['decomp'] = decomp
-                    comp_df = pd.DataFrame({'timestamp': s.index, 'observed': decomp.observed, 'trend': decomp.trend, 'seasonal': decomp.seasonal, 'resid': decomp.resid}).reset_index(drop=True)
-                    st.session_state['decomp_df'] = comp_df
-
-                    st.subheader('Графики компонентов')
-                    st.plotly_chart(px.line(comp_df, x='timestamp', y='observed', title='Observed'), use_container_width=True)
-                    st.plotly_chart(px.line(comp_df, x='timestamp', y='trend', title='Trend'), use_container_width=True)
-                    st.plotly_chart(px.line(comp_df, x='timestamp', y='seasonal', title='Seasonal'), use_container_width=True)
-                    st.plotly_chart(px.line(comp_df, x='timestamp', y='resid', title='Residuals'), use_container_width=True)
-
-                    st.success('Декомпозиция выполнена и сохранена в сессии (decomp, decomp_df).')
-
-                    st.subheader('Анализ компонентов')
-                    trend_nonnull = comp_df['trend'].dropna()
-                    if len(trend_nonnull) > 2:
-                        xnum = np.arange(len(trend_nonnull))
-                        coef = np.polyfit(xnum, trend_nonnull.values, 1)
-                        slope = coef[0]
-                        st.write(f'- Приблизительный линейный наклон тренда: {slope:.6f} ({"вырос" if slope>0 else "упал"}).')
-                    else:
-                        st.write('- Слишком мало данных в компоненте trend для оценки наклона.')
-
-                    seasonal = comp_df['seasonal'].dropna()
-                    if not seasonal.empty:
-                        amp = seasonal.max() - seasonal.min()
-                        st.write(f'- Амплитуда сезонной компоненты: {amp:.4f} (max={seasonal.max():.4f}, min={seasonal.min():.4f}).')
-
-                    resid = comp_df['resid'].dropna()
-                    st.subheader('Диагностика остатков')
-                    st.write(f'- Длина остатков: {len(resid)}')
-                    if len(resid) > 3:
-                        adf_r = run_adf(resid)
-                        kpss_r = run_kpss(resid)
-                        st.write('ADF (resid):', adf_r)
-                        st.write('KPSS (resid):', kpss_r)
-                        a_stat = ('pvalue' in adf_r) and (adf_r['pvalue'] < 0.05)
-                        k_stat = ('pvalue' in kpss_r) and (kpss_r['pvalue'] > 0.05)
-                        if a_stat and k_stat:
-                            st.success('Остатки выглядят стационарными по ADF и KPSS — декомпозиция адекватна.')
-                        else:
-                            st.warning('Остатки, возможно, нестационарны. Посмотрите на график остатков и подумайте о дополнительных преобразованиях или изменении периода/модели.')
-                    else:
-                        st.info('Недостаточно данных для тестов остатков.')
-
-                    st.download_button('Скачать компоненты (CSV)', data=comp_df.to_csv(index=False).encode('utf-8'), file_name='decomposition_components.csv', mime='text/csv')
-
-                except Exception as e:
-                    st.error(f'Ошибка при декомпозиции: {e}')
-
-    st.info('Этап 3.7 завершён. Дальше можно делать ACF/PACF на остатках, моделирование или формирование отчёта.')
-
-    # ---------------- 3.8 Web interface & report export ----------------
-    st.header('Этап 3.8 — Веб-интерфейс, конфигурация и экспорт отчёта')
-    st.markdown('Здесь собраны управляющие элементы для быстрой генерации HTML-отчёта и экспорта результатов. Отчёт включает: график ряда, скользящее среднее, матрицу корреляций, ACF/PACF и декомпозицию.')
-
-    # Unified controls
-    with st.expander('Параметры для отчёта'):
-        report_target = st.selectbox('Target для отчёта', options=numeric_cols, index=0)
-        report_features = st.multiselect('Доп. признаки для отчёта (включаются в корреляции)', options=numeric_cols, default=[c for c in numeric_cols if c != report_target][:2])
-        report_roll = st.number_input('Окно для скользящего среднего в отчёте', min_value=2, max_value=365, value=30)
-        report_acf_lags = st.number_input('nlags для ACF/PACF в отчёте', min_value=10, max_value=500, value=40)
-        report_period = st.selectbox('Период для декомпозиции в отчёте', options=[None, 7, 30, 365], index=1)
-
-    if st.button('Сгенерировать и показать отчёт (вкладки ниже)'):
-        # prepare figures
-        figs = {}
-        # time series with rolling
-        s = df_clean.set_index('timestamp')[report_target].dropna()
-        fig_series = go.Figure()
-        fig_series.add_trace(go.Scatter(x=s.index, y=s.values, mode='lines', name='observed'))
-        fig_series.add_trace(go.Scatter(x=s.rolling(window=report_roll, min_periods=1).mean().index, y=s.rolling(window=report_roll, min_periods=1).mean().values, mode='lines', name=f'roll_mean_{report_roll}'))
-        fig_series.update_layout(title=f'Series: {report_target}', height=350)
-        figs['series'] = fig_series
-
-        # corr
-        corr_cols = [report_target] + report_features
-        corr_df = df_clean[corr_cols].corr()
-        figs['corr'] = px.imshow(corr_df, text_auto=True, title='Correlation matrix')
-
-        # decomposition (if available)
-        if 'decomp_df' in st.session_state:
-            comp_df = st.session_state['decomp_df']
-            figs['decomp_observed'] = px.line(comp_df, x='timestamp', y='observed', title='Observed')
-            figs['decomp_trend'] = px.line(comp_df, x='timestamp', y='trend', title='Trend')
-            figs['decomp_seasonal'] = px.line(comp_df, x='timestamp', y='seasonal', title='Seasonal')
-            figs['decomp_resid'] = px.line(comp_df, x='timestamp', y='resid', title='Residuals')
-        else:
-            figs['decomp_observed'] = figs['decomp_trend'] = figs['decomp_seasonal'] = figs['decomp_resid'] = None
-
-        # acf/pacf (plotly version)
-        try:
-            acf_vals, acf_conf, pacf_vals, pacf_conf = get_acf_pacf_with_conf(s, nlags=int(report_acf_lags), alpha=0.05)
-            acf_fig, pacf_fig = plotly_acf_pacf(acf_vals, acf_conf, pacf_vals, pacf_conf, max_lag=int(report_acf_lags), title_prefix=report_target)
-            figs['acf'] = acf_fig
-            figs['pacf'] = pacf_fig
-        except Exception:
-            figs['acf'] = figs['pacf'] = None
-
-        # tables
-        tables = {'Descriptive': descriptive_statistics(df_clean, corr_cols), 'Correlation': corr_df}
-
-        # show in tabs
-        tab1, tab2, tab3 = st.tabs(['Графики', 'Таблицы', 'Экспорт'])
-        with tab1:
-            st.subheader('Временной ряд и rolling')
-            st.plotly_chart(figs['series'], use_container_width=True)
-            st.subheader('Матрица корреляций')
-            st.plotly_chart(figs['corr'], use_container_width=True)
-            if figs.get('decomp_observed') is not None:
-                st.subheader('Декомпозиция')
-                st.plotly_chart(figs['decomp_observed'], use_container_width=True)
-                st.plotly_chart(figs['decomp_trend'], use_container_width=True)
-                st.plotly_chart(figs['decomp_seasonal'], use_container_width=True)
-                st.plotly_chart(figs['decomp_resid'], use_container_width=True)
-            if figs.get('acf') is not None:
-                st.subheader('ACF / PACF')
-                st.plotly_chart(figs['acf'], use_container_width=True)
-                st.plotly_chart(figs['pacf'], use_container_width=True)
-
-        with tab2:
-            st.subheader('Таблицы')
-            for name, table in tables.items():
-                st.write(name)
-                st.dataframe(table)
-
-        with tab3:
-            st.subheader('Экспорт отчёта')
-            params = {'roll': int(report_roll), 'acf_lags': int(report_acf_lags), 'period': report_period}
-            html = generate_html_report(df_clean, report_target, report_features, params, figs, tables)
-            html_bytes = html.encode('utf-8')
-            st.download_button('Скачать HTML-отчёт', data=html_bytes, file_name='ts_report.html', mime='text/html')
-
-            # try PDF (if pdfkit available)
-            try:
-                import pdfkit
-
-                # Попытка конвертировать HTML в PDF (требует установленного wkhtmltopdf)
-                pdf_bytes = pdfkit.from_string(html, False)
-                st.download_button('Скачать PDF-отчёт', data=pdf_bytes, file_name='ts_report.pdf',
-                                   mime='application/pdf')
-            except Exception:
-                st.info(
-                    'PDF-конверсия недоступна (pdfkit/wkhtmltopdf не установлены). Скачайте HTML и конвертируйте локально, если нужно.')
-
-        st.info(
-            'Этап 3.8 завершён — приложение покрывает 3.2–3.8. Проверьте, всё ли работает локально и пришлите ошибки, если будут.')