Update app.py

app.py

@@ -1,4 +1,5 @@
-# app.py — ST_GR (Gamma Ray) app adapted from your UCS app, same flow & design
+# app.py — ST_Log_GR (Gamma Ray) — UI aligned with TS/Tc apps
+
 import io, json, os, base64, math
 from pathlib import Path
 import streamlit as st
@@ -7,7 +8,7 @@ import numpy as np
 import joblib
 from datetime import datetime
 
-# Matplotlib for PREVIEW modal and for the CROSS-PLOT (static)
+# Matplotlib (static plots: preview, cross-plot)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
@@ -24,13 +25,13 @@ TAGLINE  = "Real-Time Gamma Ray Prediction"
 
 FEATURES = ["GPM", "SPP", "RPM", "WOB", "T", "ROP"]
 
-# Column name of the target you trained on
-TARGET = "log(GR)"          # if your sheet uses a different name, set it here
+# Target used during training
+TARGET = "log(GR)"           # set to your training target column name if different
 
-# >>> IMPORTANT: set the transform you used in training <<<
-TARGET_TRANSFORM = "log10"  # use "log10" if trained on log10(GR); use "ln" if trained on ln(GR)
+# Inverse transform used to map predictions/target back to API
+TARGET_TRANSFORM = "log10"   # "log10" for log10(GR); "ln" for ln(GR); "none" for raw
 
-# Column that contains real GR in API (for metrics/plots). If absent, the app will invert TARGET.
+# Column with actual GR in API units (if present)
 ACTUAL_COL = "GR"
 
 MODELS_DIR = Path("models")
@@ -40,10 +41,10 @@ MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
 # ---- Plot sizing controls ----
-CROSS_W = 350    # px (matplotlib figure size; Streamlit will still scale)
+CROSS_W = 350
 CROSS_H = 350
-TRACK_H = 1000   # px (plotly height)
-TRACK_W = 500    # px (plotly width)
+TRACK_H = 1000
+TRACK_W = 500
 FONT_SZ  = 13
 BOLD_FONT = "Arial Black, Arial, sans-serif"
 
@@ -52,71 +53,47 @@ BOLD_FONT = "Arial Black, Arial, sans-serif"
 # =========================
 st.set_page_config(page_title=APP_NAME, page_icon="logo.png", layout="wide")
 
-# General CSS
 st.markdown("""
 <style>
  .brand-logo { width: 200px; height: auto; object-fit: contain; }
- .sidebar-header { display:flex; align-items:center; gap:12px; }
- .sidebar-header .text h1 { font-size: 1.05rem; margin:0; line-height:1.1; }
- .sidebar-header .text .tag { font-size: .85rem; color:#6b7280; margin:2px 0 0; }
  .centered-container { display:flex; flex-direction:column; align-items:center; text-align:center; }
+ .main .block-container { overflow: unset !important; }
+ div[data-testid="stVerticalBlock"] { overflow: unset !important; }
+
+ /* Sticky preview expander + its tabs */
+ div[data-testid="stExpander"] > details > summary {
+   position: sticky; top: 0; z-index: 10; background: #fff; border-bottom: 1px solid #eee;
+ }
+ div[data-testid="stExpander"] div[data-baseweb="tab-list"] {
+   position: sticky; top: 42px; z-index: 9; background: #fff; padding-top: 6px;
+ }
+
+ /* Hide uploader helper text */
+ section[data-testid="stFileUploader"] div[data-testid="stMarkdownContainer"]{display:none !important;}
+ section[data-testid="stFileUploader"] [data-testid="stFileUploaderDropzone"] > div:first-child{display:none !important;}
+ section[data-testid="stFileUploader"] [data-testid="stFileUploaderInstructions"]{display:none !important;}
+ section[data-testid="stFileUploader"] p, section[data-testid="stFileUploader"] small{display:none !important;}
+
+ /* Message boxes */
+ .st-message-box { background:#f0f2f6; color:#333; padding:10px; border-radius:10px; border:1px solid #e6e9ef; }
+ .st-message-box.st-success { background:#d4edda; color:#155724; border-color:#c3e6cb; }
+ .st-message-box.st-warning { background:#fff3cd; color:#856404; border-color:#ffeeba; }
+ .st-message-box.st-error { background:#f8d7da; color:#721c24; border-color:#f5c6cb; }
 </style>
 """, unsafe_allow_html=True)
 
-# Allow sticky bits (preview expander header & tabs)
-st.markdown("""
-<style>
-.main .block-container { overflow: unset !important; }
-div[data-testid="stVerticalBlock"] { overflow: unset !important; }
-</style>
-""", unsafe_allow_html=True)
-
-# Hide uploader helper text
-st.markdown("""
-<style>
-section[data-testid="stFileUploader"] div[data-testid="stMarkdownContainer"]{display:none !important;}
-section[data-testid="stFileUploader"] [data-testid="stFileUploaderDropzone"] > div:first-child{display:none !important;}
-section[data-testid="stFileUploader"] [data-testid="stFileUploaderInstructions"]{display:none !important;}
-section[data-testid="stFileUploader"] p, section[data-testid="stFileUploader"] small{display:none !重要;}
-</style>
-""", unsafe_allow_html=True)
-
-# Sticky Preview expander & its tabs
-st.markdown("""
-<style>
-div[data-testid="stExpander"] > details > summary {
- position: sticky; top: 0; z-index: 10; background: #fff; border-bottom: 1px solid #eee;
-}
-div[data-testid="stExpander"] div[data-baseweb="tab-list"] {
- position: sticky; top: 42px; z-index: 9; background: #fff; padding-top: 6px;
-}
-</style>
-""", unsafe_allow_html=True)
-
-# Center text in all pandas Styler tables (headers + cells)
 TABLE_CENTER_CSS = [
     dict(selector="th", props=[("text-align", "center")]),
     dict(selector="td", props=[("text-align", "center")]),
 ]
 
-# Message box styles
-st.markdown("""
-<style>
-.st-message-box { background:#f0f2f6; color:#333; padding:10px; border-radius:10px; border:1px solid #e6e9ef; }
-.st-message-box.st-success { background:#d4edda; color:#155724; border-color:#c3e6cb; }
-.st-message-box.st-warning { background:#fff3cd; color:#856404; border-color:#ffeeba; }
-.st-message-box.st-error { background:#f8d7da; color:#721c24; border-color:#f5c6cb; }
-</style>
-""", unsafe_allow_html=True)
-
 # =========================
 # Password gate
 # =========================
 def inline_logo(path="logo.png") -> str:
     try:
         p = Path(path)
-        if not p.exists():
-            return ""
+        if not p.exists(): return ""
         return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
     except Exception:
         return ""
@@ -162,9 +139,7 @@ def rmse(y_true, y_pred) -> float:
 def pearson_r(y_true, y_pred) -> float:
     a = np.asarray(y_true, dtype=float)
     p = np.asarray(y_pred, dtype=float)
-    # Check for constant arrays
-    if a.size < 2 or np.all(a == a[0]) or np.all(p == p[0]):
-        return float("nan")
+    if a.size < 2 or np.all(a == a[0]) or np.all(p == p[0]): return float("nan")
     return float(np.corrcoef(a, p)[0, 1])
 
 @st.cache_resource(show_spinner=False)
@@ -182,10 +157,10 @@ def read_book_bytes(b: bytes):
 
 def normalize_df(df: pd.DataFrame) -> pd.DataFrame:
     out = df.copy()
-    out.columns = [str(c).strip() for c in out.columns]
+    out.columns = [str(c).strip().replace("  ", " ") for c in out.columns]
     return out
 
-def ensure_cols(df, cols):
+def ensure_cols(df: pd.DataFrame, cols: list[str]) -> bool:
     miss = [c for c in cols if c not in df.columns]
     if miss:
         st.error(f"Missing columns: {miss}\nFound: {list(df.columns)}")
@@ -195,8 +170,7 @@ def ensure_cols(df, cols):
 def find_sheet(book, names):
     low2orig = {k.lower(): k for k in book.keys()}
     for nm in names:
-        if nm.lower() in low2orig:
-            return low2orig[nm.lower()]
+        if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
 def _nice_tick0(xmin: float, step: int = 5) -> float:
@@ -207,9 +181,9 @@ def df_centered_rounded(df: pd.DataFrame, hide_index=True):
     numcols = out.select_dtypes(include=[np.number]).columns
     styler = (
         out.style
-            .format({c: "{:.2f}" for c in numcols})
-            .set_properties(**{"text-align": "center"})
-            .set_table_styles(TABLE_CENTER_CSS)
+          .format({c: "{:.2f}" for c in numcols})
+          .set_properties(**{"text-align": "center"})
+          .set_table_styles(TABLE_CENTER_CSS)
     )
     st.dataframe(styler, use_container_width=True, hide_index=hide_index)
 
@@ -223,10 +197,7 @@ def inverse_target(x: np.ndarray, transform: str) -> np.ndarray:
     return x  # "none"
 
 def to_actual_series(df: pd.DataFrame, target_col: str, actual_col_hint: str, transform: str) -> pd.Series:
-    """
-    Return the 'actual GR' series (API).
-    If an explicit actual column exists, use it; else invert the target.
-    """
+    # Prefer explicit GR column if available; else invert target
     if actual_col_hint and actual_col_hint in df.columns:
         return pd.Series(df[actual_col_hint], dtype=float)
     if target_col in df.columns:
@@ -235,7 +206,7 @@ def to_actual_series(df: pd.DataFrame, target_col: str, actual_col_hint: str, tr
         return pd.Series(df["GR"], dtype=float)
     raise ValueError("Cannot find actual GR column or target to invert.")
 
-# === Excel export helpers =================================================
+# === Excel export helpers (TS/Tc-style multiselect) =======================
 def _excel_engine() -> str:
     try:
         import xlsxwriter  # noqa: F401
@@ -257,127 +228,157 @@ def _round_numeric(df: pd.DataFrame, ndigits: int = 2) -> pd.DataFrame:
 
 def _summary_table(df: pd.DataFrame, cols: list[str]) -> pd.DataFrame:
     cols = [c for c in cols if c in df.columns]
-    if not cols:
-        return pd.DataFrame()
+    if not cols: return pd.DataFrame()
     tbl = (df[cols]
             .agg(['min','max','mean','std'])
             .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
             .reset_index(names="Field"))
-    return _round_numeric(tbl)
+    return _round_numeric(tbl, 2)
 
 def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
-    if not ranges:
-        return pd.DataFrame()
+    if not ranges: return pd.DataFrame()
     df = pd.DataFrame(ranges).T.reset_index()
     df.columns = ["Feature", "Min", "Max"]
-    return _round_numeric(df)
+    return _round_numeric(df, 2)
 
-def build_export_workbook() -> tuple[bytes|None, str|None, list[str]]:
+def _excel_autofit(writer, sheet_name: str, df: pd.DataFrame, min_w: int = 8, max_w: int = 40):
+    try:
+        import xlsxwriter  # noqa: F401
+    except Exception:
+        return
+    ws = writer.sheets[sheet_name]
+    for i, col in enumerate(df.columns):
+        series = df[col].astype(str)
+        max_len = max([len(str(col))] + series.map(len).tolist())
+        ws.set_column(i, i, max(min_w, min(max_len + 2, max_w)))
+    ws.freeze_panes(1, 0)
+
+def _available_sections() -> list[str]:
     res = st.session_state.get("results", {})
-    if not res:
-        return None, None, []
+    sections = []
+    if "Train" in res:       sections += ["Training","Training_Metrics","Training_Summary"]
+    if "Test" in res:        sections += ["Testing","Testing_Metrics","Testing_Summary"]
+    if "Validate" in res:    sections += ["Validation","Validation_Metrics","Validation_Summary","Validation_OOR"]
+    if "PredictOnly" in res: sections += ["Prediction","Prediction_Summary","Prediction_OOR"]
+    if st.session_state.get("train_ranges"): sections += ["Training_Ranges"]
+    sections += ["Info"]
+    return sections
+
+def build_export_workbook(selected: list[str], ndigits: int = 2, do_autofit: bool = True) -> tuple[bytes|None, str|None, list[str]]:
+    res = st.session_state.get("results", {})
+    if not res: return None, None, []
 
     sheets: dict[str, pd.DataFrame] = {}
     order: list[str] = []
 
     # Training
-    if "Train" in res:
-        tr = _round_numeric(res["Train"])
-        sheets["Training"] = tr; order.append("Training")
-        m = res.get("m_train", {})
-        if m:
-            sheets["Training_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Training_Metrics")
-        tr_cols = FEATURES + [c for c in ["GR_Actual","GR_Pred"] if c in tr.columns]
-        s = _summary_table(tr, tr_cols)
+    if "Training" in selected and "Train" in res:
+        sheets["Training"] = _round_numeric(res["Train"], ndigits); order.append("Training")
+    if "Training_Metrics" in selected and res.get("m_train"):
+        sheets["Training_Metrics"] = _round_numeric(pd.DataFrame([res["m_train"]]), ndigits); order.append("Training_Metrics")
+    if "Training_Summary" in selected and "Train" in res:
+        tr_cols = FEATURES + [c for c in ["GR_Actual","GR_Pred"] if c in res["Train"].columns]
+        s = _summary_table(res["Train"], tr_cols)
         if not s.empty:
             sheets["Training_Summary"] = s; order.append("Training_Summary")
 
     # Testing
-    if "Test" in res:
-        te = _round_numeric(res["Test"])
-        sheets["Testing"] = te; order.append("Testing")
-        m = res.get("m_test", {})
-        if m:
-            sheets["Testing_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Testing_Metrics")
-        te_cols = FEATURES + [c for c in ["GR_Actual","GR_Pred"] if c in te.columns]
-        s = _summary_table(te, te_cols)
+    if "Testing" in selected and "Test" in res:
+        sheets["Testing"] = _round_numeric(res["Test"], ndigits); order.append("Testing")
+    if "Testing_Metrics" in selected and res.get("m_test"):
+        sheets["Testing_Metrics"] = _round_numeric(pd.DataFrame([res["m_test"]]), ndigits); order.append("Testing_Metrics")
+    if "Testing_Summary" in selected and "Test" in res:
+        te_cols = FEATURES + [c for c in ["GR_Actual","GR_Pred"] if c in res["Test"].columns]
+        s = _summary_table(res["Test"], te_cols)
         if not s.empty:
             sheets["Testing_Summary"] = s; order.append("Testing_Summary")
 
     # Validation
-    if "Validate" in res:
-        va = _round_numeric(res["Validate"])
-        sheets["Validation"] = va; order.append("Validation")
-        m = res.get("m_val", {})
-        if m:
-            sheets["Validation_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Validation_Metrics")
-        sv = res.get("sv_val", {})
-        if sv:
-            sheets["Validation_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Validation_Summary")
-        oor_tbl = res.get("oor_tbl")
-        if isinstance(oor_tbl, pd.DataFrame) and not oor_tbl.empty:
-            sheets["Validation_OOR"] = _round_numeric(oor_tbl.reset_index(drop=True)); order.append("Validation_OOR")
-
-    # Prediction (no actual)
-    if "PredictOnly" in res:
-        pr = _round_numeric(res["PredictOnly"])
-        sheets["Prediction"] = pr; order.append("Prediction")
-        svp = res.get("sv_pred", {})
-        if svp:
-            sheets["Prediction_Summary"] = _round_numeric(pd.DataFrame([svp])); order.append("Prediction_Summary")
-        oor_tbl_p = res.get("oor_tbl_pred")
-        if isinstance(oor_tbl_p, pd.DataFrame) and not oor_tbl_p.empty:
-            sheets["Prediction_OOR"] = _round_numeric(oor_tbl_p.reset_index(drop=True)); order.append("Prediction_OOR")
+    if "Validation" in selected and "Validate" in res:
+        sheets["Validation"] = _round_numeric(res["Validate"], ndigits); order.append("Validation")
+    if "Validation_Metrics" in selected and res.get("m_val"):
+        sheets["Validation_Metrics"] = _round_numeric(pd.DataFrame([res["m_val"]]), ndigits); order.append("Validation_Metrics")
+    if "Validation_Summary" in selected and res.get("sv_val"):
+        sheets["Validation_Summary"] = _round_numeric(pd.DataFrame([res["sv_val"]]), ndigits); order.append("Validation_Summary")
+    if "Validation_OOR" in selected and isinstance(res.get("oor_tbl"), pd.DataFrame) and not res["oor_tbl"].empty:
+        sheets["Validation_OOR"] = _round_numeric(res["oor_tbl"].reset_index(drop=True), ndigits); order.append("Validation_OOR")
+
+    # Prediction
+    if "Prediction" in selected and "PredictOnly" in res:
+        sheets["Prediction"] = _round_numeric(res["PredictOnly"], ndigits); order.append("Prediction")
+    if "Prediction_Summary" in selected and res.get("sv_pred"):
+        sheets["Prediction_Summary"] = _round_numeric(pd.DataFrame([res["sv_pred"]]), ndigits); order.append("Prediction_Summary")
+    if "Prediction_OOR" in selected and isinstance(res.get("oor_tbl_pred"), pd.DataFrame) and not res["oor_tbl_pred"].empty:
+        sheets["Prediction_OOR"] = _round_numeric(res["oor_tbl_pred"].reset_index(drop=True), ndigits); order.append("Prediction_OOR")
 
     # Training ranges
-    tr_ranges = st.session_state.get("train_ranges")
-    if tr_ranges:
-        rr = _train_ranges_df(tr_ranges)
-        if not rr.empty:
-            sheets["Training_Ranges"] = rr; order.append("Training_Ranges")
-
-    # Info sheet
-    info = pd.DataFrame([
-        {"Key": "AppName",          "Value": APP_NAME},
-        {"Key": "Tagline",          "Value": TAGLINE},
-        {"Key": "Target",           "Value": TARGET},
-        {"Key": "TargetTransform",  "Value": TARGET_TRANSFORM},
-        {"Key": "ActualColumn",     "Value": ACTUAL_COL},
-        {"Key": "Features",         "Value": ", ".join(FEATURES)},
-        {"Key": "ExportedAt",       "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
-    ])
-    sheets["Info"] = info; order.append("Info")
-
-    # Write workbook to memory
+    if "Training_Ranges" in selected and st.session_state.get("train_ranges"):
+        sheets["Training_Ranges"] = _train_ranges_df(st.session_state["train_ranges"]); order.append("Training_Ranges")
+
+    # Info
+    if "Info" in selected:
+        info = pd.DataFrame([
+            {"Key": "AppName",          "Value": APP_NAME},
+            {"Key": "Tagline",          "Value": TAGLINE},
+            {"Key": "Target",           "Value": TARGET},
+            {"Key": "TargetTransform",  "Value": TARGET_TRANSFORM},
+            {"Key": "ActualColumn",     "Value": ACTUAL_COL},
+            {"Key": "Features",         "Value": ", ".join(FEATURES)},
+            {"Key": "ExportedAt",       "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
+        ])
+        sheets["Info"] = info; order.append("Info")
+
+    if not order: return None, None, []
+
     bio = io.BytesIO()
-    with pd.ExcelWriter(bio, engine=_excel_engine()) as writer:
+    engine = _excel_engine()
+    with pd.ExcelWriter(bio, engine=engine) as writer:
         for name in order:
             df = sheets[name]
-            df.to_excel(writer, sheet_name=_excel_safe_name(name), index=False)
+            sheet = _excel_safe_name(name)
+            df.to_excel(writer, sheet_name=sheet, index=False)
+            _excel_autofit(writer, sheet, df)
     bio.seek(0)
-
     fname = f"GR_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
     return bio.getvalue(), fname, order
 
-def render_export_button(key: str = "export_main") -> None:
-    """Bottom-of-page export button (main content area)."""
-    data, fname, names = build_export_workbook()
+def render_export_button(phase_key: str) -> None:
+    res = st.session_state.get("results", {})
+    if not res: return
     st.divider()
     st.markdown("### Export to Excel")
+
+    options = _available_sections()
+    selected_sheets = st.multiselect(
+        "Sheets to include",
+        options=options,
+        default=[],
+        placeholder="Choose option(s)",
+        help="Pick the sheets you want to include in the Excel export.",
+        key=f"sheets_{phase_key}",
+    )
+
+    if not selected_sheets:
+        st.caption("Select one or more sheets above to enable the export.")
+        st.download_button("⬇️ Export Excel", data=b"", file_name="GR_Export.xlsx",
+                           mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                           disabled=True, key=f"download_{phase_key}")
+        return
+
+    data, fname, names = build_export_workbook(selected=selected_sheets, ndigits=2, do_autofit=True)
     if names:
-        st.caption("Includes sheets: " + ", ".join(names))
+        st.caption("Will include: " + ", ".join(names))
     st.download_button(
-        label="⬇️ Export Excel",
+        "⬇️ Export Excel",
         data=(data or b""),
         file_name=(fname or "GR_Export.xlsx"),
         mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
         disabled=(data is None),
-        help="Exports all available results, metrics, summaries, OOR, training ranges, and info.",
-        key=key,
+        key=f"download_{phase_key}",
     )
 
 # =========================
-# Cross plot (Matplotlib) — auto limits for GR
+# Cross plot (Matplotlib)
 # =========================
 def _nice_bounds(arr_min, arr_max, n_ticks=6):
     if not np.isfinite(arr_min) or not np.isfinite(arr_max):
@@ -403,11 +404,7 @@ def cross_plot_static(actual, pred):
     ticks = np.arange(fixed_min, fixed_max + step, step)
 
     dpi = 110
-    fig, ax = plt.subplots(
-        figsize=(CROSS_W / dpi, CROSS_H / dpi),
-        dpi=dpi,
-        constrained_layout=False
-    )
+    fig, ax = plt.subplots(figsize=(CROSS_W / dpi, CROSS_H / dpi), dpi=dpi, constrained_layout=False)
 
     ax.scatter(a, p, s=14, c=COLORS["pred"], alpha=0.9, linewidths=0)
     ax.plot([fixed_min, fixed_max], [fixed_min, fixed_max],
@@ -415,22 +412,19 @@ def cross_plot_static(actual, pred):
 
     ax.set_xlim(fixed_min, fixed_max)
     ax.set_ylim(fixed_min, fixed_max)
-    ax.set_xticks(ticks)
-    ax.set_yticks(ticks)
+    ax.set_xticks(ticks); ax.set_yticks(ticks)
     ax.set_aspect("equal", adjustable="box")
 
     fmt = FuncFormatter(lambda x, _: f"{int(x):,}")
-    ax.xaxis.set_major_formatter(fmt)
-    ax.yaxis.set_major_formatter(fmt)
+    ax.xaxis.set_major_formatter(fmt); ax.yaxis.set_major_formatter(fmt)
 
-    ax.set_xlabel("Actual GR (API)",     fontweight="bold", fontsize=10, color="black")
-    ax.set_ylabel("Predicted GR (API)",  fontweight="bold", fontsize=10, color="black")
+    ax.set_xlabel("Actual GR (API)",    fontweight="bold", fontsize=10, color="black")
+    ax.set_ylabel("Predicted GR (API)", fontweight="bold", fontsize=10, color="black")
     ax.tick_params(labelsize=8, colors="black")
 
     ax.grid(True, linestyle=":", alpha=0.3)
     for spine in ax.spines.values():
-        spine.set_linewidth(1.1)
-        spine.set_color("#444")
+        spine.set_linewidth(1.1); spine.set_color("#444")
 
     fig.subplots_adjust(left=0.16, bottom=0.16, right=0.98, top=0.98)
     return fig
@@ -439,25 +433,18 @@ def cross_plot_static(actual, pred):
 # Track plot (Plotly) — y-axis reversed
 # =========================
 def track_plot(df, include_actual=True, pred_col="GR_Pred", actual_col="GR"):
-    # ensure 1D series even if duplicate col names exist
     def _col_1d(frame: pd.DataFrame, col: str) -> pd.Series:
-        if col not in frame.columns:
-            return pd.Series(dtype=float)
+        if col not in frame.columns: return pd.Series(dtype=float)
         v = frame[col]
-        if isinstance(v, pd.DataFrame):
-            v = v.iloc[:, 0]
+        if isinstance(v, pd.DataFrame): v = v.iloc[:, 0]
         return pd.Series(v, dtype=float)
 
-    # Depth (or index) for y
     depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
     if depth_col is not None:
-        y = pd.Series(df[depth_col]).astype(float)
-        ylab = depth_col
+        y = pd.Series(df[depth_col]).astype(float); ylab = depth_col
     else:
-        y = pd.Series(np.arange(1, len(df) + 1), dtype=float)
-        ylab = "Point Index"
+        y = pd.Series(np.arange(1, len(df) + 1), dtype=float); ylab = "Point Index"
 
-    # X (GR) domain and ticks
     x_pred = _col_1d(df, pred_col)
     if include_actual and actual_col in df.columns:
         x_act = _col_1d(df, actual_col)
@@ -491,10 +478,8 @@ def track_plot(df, include_actual=True, pred_col="GR_Pred", actual_col="GR"):
         paper_bgcolor="#fff", plot_bgcolor="#fff",
         margin=dict(l=64, r=16, t=36, b=48), hovermode="closest",
         font=dict(size=FONT_SZ, color="#000"),
-        legend=dict(
-            x=0.98, y=0.05, xanchor="right", yanchor="bottom",
-            bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1
-        ),
+        legend=dict(x=0.98, y=0.05, xanchor="right", yanchor="bottom",
+                    bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1),
         legend_title_text=""
     )
     fig.update_xaxes(
@@ -502,11 +487,13 @@ def track_plot(df, include_actual=True, pred_col="GR_Pred", actual_col="GR"):
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
         tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
         side="top", range=[xmin, xmax],
-        ticks="outside", tickformat=",.0f", tickmode="auto", tick0=tick0,
+        ticks="outside",
+        tickformat=",.0f",
+        tickmode="auto",
+        tick0=tick0,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True,
     )
-    # Reverse y-axis universally (top=shallow, bottom=deep)
     fig.update_yaxes(
         title_text=ylab,
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
@@ -514,58 +501,54 @@ def track_plot(df, include_actual=True, pred_col="GR_Pred", actual_col="GR"):
         autorange="reversed",
         ticks="outside",
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True,
     )
-
     return fig
 
-# ---------- Preview modal (matplotlib) — y-axis reversed ----------
+# ---------- Preview (Matplotlib) — colorful tracks; shared Y; ticks only left ----------
 def preview_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
     if n == 0:
         fig, ax = plt.subplots(figsize=(4, 2))
-        ax.text(0.5, 0.5, "No selected columns", ha="center", va="center"); ax.axis("off")
+        ax.text(0.5, 0.5, "No selected columns", ha="center", va="center")
+        ax.axis("off")
         return fig
 
     depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
     if depth_col is not None:
-        y = pd.Series(df[depth_col], dtype=float)
+        y = pd.to_numeric(df[depth_col], errors="coerce")
         ylab = depth_col
     else:
         y = pd.Series(np.arange(1, len(df) + 1), dtype=float)
         ylab = "Point Index"
 
-    fig, axes = plt.subplots(1, n, figsize=(2.4 * n, 7.0), dpi=100, sharey=False)
+    # Stable qualitative colors
+    cmap = plt.get_cmap("tab20")
+    col_colors = {col: cmap(i % cmap.N) for i, col in enumerate(cols)}
+
+    fig, axes = plt.subplots(1, n, figsize=(2.3 * n, 7.0), sharey=True, dpi=100)
     if n == 1:
         axes = [axes]
 
-    for ax, col in zip(axes, cols):
-        ax.plot(pd.to_numeric(df[col], errors="coerce"), y, '-', lw=1.4, color="#333")
+    y_min, y_max = float(np.nanmin(y)), float(np.nanmax(y))
+
+    for i, (ax, col) in enumerate(zip(axes, cols)):
+        x = pd.to_numeric(df[col], errors="coerce")
+        ax.plot(x, y, '-', lw=1.8, color=col_colors[col])
         ax.set_xlabel(col)
-        ax.xaxis.set_label_position('top')
-        ax.xaxis.tick_top()
-        ax.set_ylim(float(y.min()), float(y.max()))
-        ax.invert_yaxis()
+        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top()
+        ax.set_ylim(y_max, y_min)  # reverse Y (Depth down)
         ax.grid(True, linestyle=":", alpha=0.3)
-        for s in ax.spines.values():
-            s.set_visible(True)
+        if i == 0:
+            ax.set_ylabel(ylab)
+        else:
+            # Hide Y ticks and labels for non-left tracks
+            ax.tick_params(axis='y', left=False, labelleft=False)
 
-    axes[0].set_ylabel(ylab)
+    fig.tight_layout()
     return fig
 
-# Modal wrapper (Streamlit compatibility)
-try:
-    dialog = st.dialog
-except AttributeError:
-    def dialog(title):
-        def deco(fn):
-            def wrapper(*args, **kwargs):
-                with st.expander(title, expanded=True):
-                    return fn(*args, **kwargs)
-            return wrapper
-        return deco
-
 # =========================
 # Load model + meta
 # =========================
@@ -583,8 +566,7 @@ def ensure_model() -> Path|None:
             r.raise_for_status()
             with open(DEFAULT_MODEL, "wb") as f:
                 for chunk in r.iter_content(1<<20):
-                    if chunk:
-                        f.write(chunk)
+                    if chunk: f.write(chunk)
         return DEFAULT_MODEL
     except Exception:
         return None
@@ -623,7 +605,7 @@ st.session_state.setdefault("dev_preview",False)
 st.session_state.setdefault("show_preview_modal", False)
 
 # =========================
-# Branding in Sidebar
+# Sidebar branding
 # =========================
 st.sidebar.markdown(f"""
     <div class="centered-container">
@@ -634,7 +616,6 @@ st.sidebar.markdown(f"""
     """, unsafe_allow_html=True
 )
 
-# Reusable sticky header
 def sticky_header(title, message):
     st.markdown(
         f"""
@@ -657,10 +638,10 @@ def sticky_header(title, message):
 # =========================
 if st.session_state.app_step == "intro":
     st.header("Welcome!")
-    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate Gamma Ray (GR) from input features.")
+    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate **Gamma Ray (GR)** from drilling data.")
     st.subheader("How It Works")
     st.markdown(
-        "1) **Upload your data to build the case and preview the performance of our model.**  \n"
+        "1) **Upload your data to build the case and preview model performance.**  \n"
         "2) Click **Run Model** to compute metrics and plots.  \n"
         "3) **Proceed to Validation** (with actual GR) or **Proceed to Prediction** (no GR)."
     )
@@ -689,18 +670,15 @@ if st.session_state.app_step == "dev":
         st.session_state.dev_preview = True
 
     run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
-    if st.sidebar.button("Proceed to Validation ▶", use_container_width=True):
-        st.session_state.app_step="validate"; st.rerun()
-    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
-        st.session_state.app_step="predict"; st.rerun()
+    if st.sidebar.button("Proceed to Validation ▶", use_container_width=True): st.session_state.app_step="validate"; st.rerun()
+    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
-    # Sticky helper
     if st.session_state.dev_file_loaded and st.session_state.dev_preview:
         sticky_header("Case Building", "Previewed ✓ — now click **Run Model**.")
     elif st.session_state.dev_file_loaded:
-        sticky_header("Case Building", "📄 **Preview uploaded data** using the sidebar button, then click **Run Model**.")
+        sticky_header("Case Building", "📄 **Preview uploaded data**, then click **Run Model**.")
     else:
-        sticky_header("Case Building", "**Upload your data to build a case, then run the model to review development performance.**")
+        sticky_header("Case Building", "Upload your data to build a case, then run the model to review development performance.")
 
     if run and st.session_state.dev_file_bytes:
         book = read_book_bytes(st.session_state.dev_file_bytes)
@@ -709,18 +687,20 @@ if st.session_state.app_step == "dev":
         if sh_train is None or sh_test is None:
             st.markdown('<div class="st-message-box st-error">Workbook must include Train/Training and Test/Testing sheets.</div>', unsafe_allow_html=True)
             st.stop()
-        tr = normalize_df(book[sh_train].copy()); te = normalize_df(book[sh_test].copy())
+
+        tr = normalize_df(book[sh_train].copy())
+        te = normalize_df(book[sh_test].copy())
         if not (ensure_cols(tr, FEATURES) and ensure_cols(te, FEATURES)):
             st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True)
             st.stop()
 
-        # predictions (handle log targets)
+        # Predict (model trained on transformed target)
         tr_pred_raw = model.predict(tr[FEATURES])
         te_pred_raw = model.predict(te[FEATURES])
         tr["GR_Pred"] = inverse_target(np.asarray(tr_pred_raw, dtype=float), TARGET_TRANSFORM)
         te["GR_Pred"] = inverse_target(np.asarray(te_pred_raw, dtype=float), TARGET_TRANSFORM)
 
-        # actual GR (for metrics/plots)
+        # Actual GR for metrics/plots
         tr["GR_Actual"] = to_actual_series(tr, TARGET, ACTUAL_COL, TARGET_TRANSFORM)
         te["GR_Actual"] = to_actual_series(te, TARGET, ACTUAL_COL, TARGET_TRANSFORM)
 
@@ -740,23 +720,18 @@ if st.session_state.app_step == "dev":
         st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
         st.markdown('<div class="st-message-box st-success">Case has been built and results are displayed below.</div>', unsafe_allow_html=True)
 
-    # -------- Metrics + Plots (3 decimals here) --------
     def _dev_block(df, m):
         c1, c2, c3 = st.columns(3)
         c1.metric("R",    f"{m['R']:.3f}")
         c2.metric("RMSE", f"{m['RMSE']:.3f}")
         c3.metric("MAE",  f"{m['MAE']:.3f}")
-
-        st.markdown(
-            """
+        st.markdown("""
             <div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>
                 <strong>R:</strong> Pearson Correlation Coefficient<br>
                 <strong>RMSE:</strong> Root Mean Square Error<br>
                 <strong>MAE:</strong> Mean Absolute Error
             </div>
-            """,
-            unsafe_allow_html=True,
-        )
+        """, unsafe_allow_html=True)
 
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
@@ -771,11 +746,10 @@ if st.session_state.app_step == "dev":
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
         if "Train" in st.session_state.results:
-            with tab1:
-                _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
+            with tab1: _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
         if "Test" in st.session_state.results:
-            with tab2:
-                _dev_block(st.session_state.results["Test"],  st.session_state.results["m_test"])
+            with tab2: _dev_block(st.session_state.results["Test"],  st.session_state.results["m_test"])
+        render_export_button(phase_key="dev")
 
 # =========================
 # VALIDATION (with actual GR)
@@ -791,10 +765,8 @@ if st.session_state.app_step == "validate":
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
         st.session_state.show_preview_modal = True
     go_btn = st.sidebar.button("Predict & Validate", type="primary", use_container_width=True)
-    if st.sidebar.button("⬅ Back to Case Building", use_container_width=True):
-        st.session_state.app_step="dev"; st.rerun()
-    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
-        st.session_state.app_step="predict"; st.rerun()
+    if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
+    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
     sticky_header("Validate the Model", "Upload a dataset with the same **features** and **GR** to evaluate performance.")
 
@@ -803,10 +775,9 @@ if st.session_state.app_step == "validate":
         name = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
         df = normalize_df(book[name].copy())
         if not ensure_cols(df, FEATURES):
-            st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True)
-            st.stop()
+            st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True); st.stop()
 
-        pred_raw = model.predict(df[FEATURES])  # <-- fixed here
+        pred_raw = model.predict(df[FEATURES])
         df["GR_Pred"] = inverse_target(np.asarray(pred_raw, dtype=float), TARGET_TRANSFORM)
         try:
             df["GR_Actual"] = to_actual_series(df, TARGET, ACTUAL_COL, TARGET_TRANSFORM)
@@ -823,9 +794,10 @@ if st.session_state.app_step == "validate":
             if any_viol.any():
                 tbl = df.loc[any_viol, FEATURES].copy()
                 for c in FEATURES:
-                    if pd.api.types.is_numeric_dtype(tbl[c]):
-                        tbl[c] = tbl[c].round(2)
-                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(lambda r:", ".join([c for c,v in r.items() if v]), axis=1)
+                    if pd.api.types.is_numeric_dtype(tbl[c]): tbl[c] = tbl[c].round(2)
+                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(
+                    lambda r:", ".join([c for c,v in r.items() if v]), axis=1
+                )
 
         st.session_state.results["m_val"]={
             "R": pearson_r(df["GR_Actual"], df["GR_Pred"]),
@@ -838,9 +810,7 @@ if st.session_state.app_step == "validate":
     if "Validate" in st.session_state.results:
         m = st.session_state.results["m_val"]
         c1,c2,c3 = st.columns(3)
-        c1.metric("R", f"{m['R']:.2f}")
-        c2.metric("RMSE", f"{m['RMSE']:.2f}")
-        c3.metric("MAE", f"{m['MAE']:.2f}")
+        c1.metric("R", f"{m['R']:.3f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
         st.markdown("""
             <div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>
                 <strong>R:</strong> Pearson Correlation Coefficient<br>
@@ -852,20 +822,18 @@ if st.session_state.app_step == "validate":
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
             st.plotly_chart(
-                track_plot(st.session_state.results["Validate"],
-                           include_actual=True, pred_col="GR_Pred", actual_col="GR_Actual"),
+                track_plot(st.session_state.results["Validate"], include_actual=True, pred_col="GR_Pred", actual_col="GR_Actual"),
                 use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
             )
         with col_cross:
-            st.pyplot(
-                cross_plot_static(st.session_state.results["Validate"]["GR_Actual"],
-                                  st.session_state.results["Validate"]["GR_Pred"]),
-                use_container_width=False
-            )
+            st.pyplot(cross_plot_static(st.session_state.results["Validate"]["GR_Actual"],
+                                        st.session_state.results["Validate"]["GR_Pred"]),
+                      use_container_width=False)
+
+        render_export_button(phase_key="validate")
 
         sv = st.session_state.results["sv_val"]
-        if sv["oor"] > 0:
-            st.markdown('<div class="st-message-box st-warning">Some inputs fall outside **training min–max** ranges.</div>', unsafe_allow_html=True)
+        if sv["oor"] > 0: st.markdown('<div class="st-message-box st-warning">Some inputs fall outside **training min–max** ranges.</div>', unsafe_allow_html=True)
         if st.session_state.results["oor_tbl"] is not None:
             st.write("*Out-of-range rows (vs. Training min–max):*")
             df_centered_rounded(st.session_state.results["oor_tbl"])
@@ -884,57 +852,51 @@ if st.session_state.app_step == "predict":
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
         st.session_state.show_preview_modal = True
 
-    if st.sidebar.button("Predict", type="primary", use_container_width=True):
-        if up is not None:
-            book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
-            df = normalize_df(book[name].copy())
-            if not ensure_cols(df, FEATURES):
-                st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True)
-                st.stop()
-            pred_raw = model.predict(df[FEATURES])
-            df["GR_Pred"] = inverse_target(np.asarray(pred_raw, dtype=float), TARGET_TRANSFORM)
-            st.session_state.results["PredictOnly"]=df
-            ranges = st.session_state.train_ranges
-            oor_pct = 0.0
-            oor_tbl = None
-            if ranges:
-                any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
-                oor_pct = float(any_viol.mean()*100.0)
-                if any_viol.any():
-                    oor_tbl = df.loc[any_viol, FEATURES].copy()
-                    for c in FEATURES:
-                        if pd.api.types.is_numeric_dtype(oor_tbl[c]):
-                            oor_tbl[c] = oor_tbl[c].round(2)
-                    oor_tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(lambda r:", ".join([c for c,v in r.items() if v]), axis=1)
-            st.session_state.results["sv_pred"]={
-                "n":len(df),
-                "pred_min":float(df["GR_Pred"].min()),
-                "pred_max":float(df["GR_Pred"].max()),
-                "pred_mean":float(df["GR_Pred"].mean()),
-                "pred_std":float(df["GR_Pred"].std(ddof=0)),
-                "oor":oor_pct
-            }
-            st.session_state.results["oor_tbl_pred"] = oor_tbl
-
-    if st.sidebar.button("⬅ Back to Case Building", use_container_width=True):
-        st.session_state.app_step="dev"
-        st.rerun()
+    go_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
+    if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
 
     sticky_header("Prediction", "Upload a dataset with the feature columns (no **GR**).")
 
+    if go_btn and up is not None:
+        book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
+        df = normalize_df(book[name].copy())
+        if not ensure_cols(df, FEATURES):
+            st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True); st.stop()
+
+        pred_raw = model.predict(df[FEATURES])
+        df["GR_Pred"] = inverse_target(np.asarray(pred_raw, dtype=float), TARGET_TRANSFORM)
+        st.session_state.results["PredictOnly"]=df
+
+        ranges = st.session_state.train_ranges; oor_pct = 0.0; oor_tbl=None
+        if ranges:
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
+            oor_pct = float(any_viol.mean()*100.0)
+            if any_viol.any():
+                oor_tbl = df.loc[any_viol, FEATURES].copy()
+                for c in FEATURES:
+                    if pd.api.types.is_numeric_dtype(oor_tbl[c]): oor_tbl[c] = oor_tbl[c].round(2)
+                oor_tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(
+                    lambda r:", ".join([c for c,v in r.items() if v]), axis=1
+                )
+        st.session_state.results["sv_pred"]={
+            "n":len(df),
+            "pred_min":float(df["GR_Pred"].min()),
+            "pred_max":float(df["GR_Pred"].max()),
+            "pred_mean":float(df["GR_Pred"].mean()),
+            "pred_std":float(df["GR_Pred"].std(ddof=0)),
+            "oor":oor_pct
+        }
+        st.session_state.results["oor_tbl_pred"] = oor_tbl
+
     if "PredictOnly" in st.session_state.results:
-        df = st.session_state.results["PredictOnly"]
-        sv = st.session_state.results["sv_pred"]
+        df = st.session_state.results["PredictOnly"]; sv = st.session_state.results["sv_pred"]
+
         col_left, col_right = st.columns([2,3], gap="large")
         with col_left:
             table = pd.DataFrame({
                 "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
-                "Value":  [sv["n"],
-                           round(sv["pred_min"],2),
-                           round(sv["pred_max"],2),
-                           round(sv["pred_mean"],2),
-                           round(sv["pred_std"],2),
-                           f'{sv["oor"]:.1f}%']
+                "Value":  [sv["n"], round(sv["pred_min"],2), round(sv["pred_max"],2),
+                           round(sv["pred_mean"],2), round(sv["pred_std"],2), f'{sv["oor"]:.1f}%']
             })
             st.markdown('<div class="st-message-box st-success">Predictions ready ✓</div>', unsafe_allow_html=True)
             df_centered_rounded(table, hide_index=True)
@@ -951,6 +913,8 @@ if st.session_state.app_step == "predict":
                 use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
             )
 
+        render_export_button(phase_key="predict")
+
 # =========================
 # Preview modal (re-usable)
 # =========================
@@ -972,32 +936,23 @@ if st.session_state.show_preview_modal:
                     df = normalize_df(book_to_preview[name])
                     t1, t2 = st.tabs(["Tracks", "Summary"])
                     with t1:
-                        if any(c in df.columns for c in FEATURES):
-                            st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)
+                        present = [c for c in FEATURES if c in df.columns]
+                        if present:
+                            st.pyplot(preview_tracks(df, present), use_container_width=True)
                         else:
-                            st.info(f"None of the expected feature columns were found in this sheet. "
-                                    f"Expected any of: {FEATURES}. Found: {list(df.columns)}")
+                            st.info(f"No expected feature columns found. Expected any of: {FEATURES}. Found: {list(df.columns)}")
                     with t2:
                         present = [c for c in FEATURES if c in df.columns]
                         if present:
                             tbl = (df[present]
-                                     .agg(['min','max','mean','std'])
-                                     .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}))
-                            df_centered_rounded(tbl.reset_index(names="Feature"))
+                                    .agg(['min','max','mean','std'])
+                                    .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
+                                    .reset_index(names="Feature"))
+                            df_centered_rounded(tbl)
                         else:
                             st.info("No expected feature columns found to summarize.")
     st.session_state.show_preview_modal = False
 
-# === Bottom-of-page Export (per step) =========================================
-if st.session_state.app_step in ("dev", "validate", "predict"):
-    has_results = any(
-        k in st.session_state.results
-        for k in ("Train", "Test", "Validate", "PredictOnly")
-    )
-    if has_results:
-        render_export_button(key=f"export_{st.session_state.app_step}")
-# ==============================================================================
-
 # =========================
 # Footer
 # =========================