Update app.py

app.py

@@ -1,4 +1,5 @@
-# app.py — ST_GeoMech_YM (mirrors your UCS GUI, adapted for Young's Modulus)
+# app.py — ST_GeoMech_YM (Young's Modulus), mirrors UCS GUI
+
 import io, json, os, base64, math
 from pathlib import Path
 import streamlit as st
@@ -17,41 +18,52 @@ import plotly.graph_objects as go
 from sklearn.metrics import mean_squared_error, mean_absolute_error
 
 # =========================
-# Constants (Ym variant)
+# App identity (YM)
+# =========================
+APP_NAME = "ST_GeoMech_YM"
+TAGLINE  = "Real-Time Young's Modulus Tracking"
+
 # =========================
-FEATURES = ["WOB(klbf)", "TORQUE(kft.lbf)", "SPP(psi)", "RPM(1/min)", "ROP(ft/h)", "Flow Rate, gpm"]
-TARGET = "Actual Ym"
-PRED_COL = "Ym_Pred"
+# Constants (YM)
+# =========================
+FEATURES = [
+    "WOB(klbf)", "TORQUE(kft.lbf)", "SPP(psi)", "RPM(1/min)",
+    "ROP(ft/h)", "Flow Rate, gpm"
+]
+TARGET   = "Actual Ym"     # column with actual Young's Modulus
+PRED_COL = "Ym_Pred"       # column we will create with predictions
 
 MODELS_DIR = Path("models")
 DEFAULT_MODEL = MODELS_DIR / "ym_rf.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
+
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
 # ---- Plot sizing controls ----
 CROSS_W = 350
 CROSS_H = 350
 TRACK_H = 1000
-TRACK_W = 500
-FONT_SZ = 13
+TRACK_W = 400
+FONT_SZ  = 13
 BOLD_FONT = "Arial Black, Arial, sans-serif"
 
 # =========================
 # Page / CSS
 # =========================
-st.set_page_config(page_title="ST_GeoMech_YM", page_icon="logo.png", layout="wide")
+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; }
+ .centered-container { display:flex; flex-direction:column; align-items:center; text-align:center; }
 </style>
 """, unsafe_allow_html=True)
 
-# Sticky helpers
+# Allow sticky bits (preview expander header & tabs)
 st.markdown("""
 <style>
 .main .block-container { overflow: unset !important; }
@@ -69,7 +81,7 @@ section[data-testid="stFileUploader"] p, section[data-testid="stFileUploader"] s
 </style>
 """, unsafe_allow_html=True)
 
-# Make the Preview expander title & tabs sticky (pinned to the top)
+# Sticky Preview expander & tabs
 st.markdown("""
 <style>
 div[data-testid="stExpander"] > details > summary {
@@ -81,19 +93,19 @@ div[data-testid="stExpander"] div[data-baseweb="tab-list"] {
 </style>
 """, unsafe_allow_html=True)
 
-# Center text in all pandas Styler tables
+# 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 CSS
+# Message box styles
 st.markdown("""
 <style>
-.st-message-box { background-color: #f0f2f6; color: #333; padding: 10px; border-radius: 10px; border: 1px solid #e6e9ef; }
-.st-message-box.st-success { background-color: #d4edda; color: #155724; border-color: #c3e6cb; }
-.st-message-box.st-warning { background-color: #fff3cd; color: #856404; border-color: #ffeeba; }
-.st-message-box.st-error { background-color: #f8d7da; color: #721c24; border-color: #f5c6cb; }
+.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)
 
@@ -103,7 +115,8 @@ st.markdown("""
 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 ""
@@ -124,7 +137,7 @@ def add_password_gate() -> None:
     st.sidebar.markdown(f"""
         <div class="centered-container">
             <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-            <div style='font-weight:800;font-size:1.2rem; margin-top: 10px;'>ST_GeoMech_YM</div>
+            <div style='font-weight:800;font-size:1.2rem;'>{APP_NAME}</div>
             <div style='color:#667085;'>Smart Thinking • Secure Access</div>
         </div>
         """, unsafe_allow_html=True
@@ -149,7 +162,8 @@ 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)
-    if a.size < 2: return float("nan")
+    if a.size < 2: 
+        return float("nan")
     return float(np.corrcoef(a, p)[0, 1])
 
 @st.cache_resource(show_spinner=False)
@@ -162,31 +176,34 @@ def parse_excel(data_bytes: bytes):
     xl = pd.ExcelFile(bio)
     return {sh: xl.parse(sh) for sh in xl.sheet_names}
 
-def read_book_bytes(b: bytes): return parse_excel(b) if b else {}
+def read_book_bytes(b: bytes):
+    return parse_excel(b) if b else {}
+
+def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    out.columns = [str(c).strip() for c in out.columns]
+    # Fix common typos
+    out = out.rename(columns={
+        "Fow Rate, gpm": "Flow Rate, gpm",
+        "Fow Rate, gpm ": "Flow Rate, gpm"
+    })
+    return out
 
 def ensure_cols(df, cols):
-    """
-    Check required columns exist; auto-fix common typos first.
-    """
-    # Auto-fix known variants before checking
-    fixed = _normalize_columns(df)
-    miss = [c for c in cols if c not in fixed.columns]
+    miss = [c for c in cols if c not in df.columns]
     if miss:
-        st.error(f"Missing columns: {miss}\nFound: {list(fixed.columns)}")
+        st.error(f"Missing columns: {miss}\nFound: {list(df.columns)}")
         return False
-    # If everything exists in the fixed version, reflect back to caller
-    # (callers typically use the same df instance; we return True only)
     return True
 
-
 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: float = 0.1) -> float:
-    # Rounded start tick for continuous Ym scales (unit-agnostic)
     return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
 
 def df_centered_rounded(df: pd.DataFrame, hide_index=True):
@@ -194,13 +211,13 @@ 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)
 
-# === Excel export helpers =================================================
+# === Excel export helpers (YM) ================================================
 def _excel_engine() -> str:
     try:
         import xlsxwriter  # noqa: F401
@@ -224,11 +241,12 @@ 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()
-    tbl = (df[cols]
-            .agg(['min','max','mean','std'])
-            .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
-            .reset_index(names="Field"))
-    return tbl
+    return (
+        df[cols]
+          .agg(['min','max','mean','std'])
+          .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
+          .reset_index(names="Field")
+    )
 
 def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
     if not ranges:
@@ -238,40 +256,34 @@ def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
     return df
 
 def _excel_autofit(writer, sheet_name: str, df: pd.DataFrame, min_w: int = 8, max_w: int = 40):
-    """Auto-fit columns when using xlsxwriter."""
     try:
         import xlsxwriter  # noqa: F401
     except Exception:
         return
     ws = writer.sheets[sheet_name]
-    # header
     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)))
-    # freeze header row
     ws.freeze_panes(1, 0)
 
 def _add_sheet(sheets: dict, order: list, name: str, df: pd.DataFrame, ndigits: int):
-    if df is None or df.empty:
-        return
-    sheets[name] = _round_numeric(df, ndigits)
-    order.append(name)
+    if isinstance(df, pd.DataFrame) and not df.empty:
+        sheets[name] = _round_numeric(df, ndigits)
+        order.append(name)
 
 def _available_sections():
-    """Compute which sections exist, to build a sensible default list."""
     res = st.session_state.get("results", {})
     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 "PredictOnly" in res:  sections += ["Prediction","Prediction_Summary"]
     if st.session_state.get("train_ranges"): sections += ["Training_Ranges"]
     sections += ["Info"]
     return sections
 
 def build_export_workbook(selected: list[str], ndigits: int = 2) -> tuple[bytes|None, str|None, list[str]]:
-    """Builds an in-memory Excel workbook based on selected sheet names."""
     res = st.session_state.get("results", {})
     if not res:
         return None, None, []
@@ -285,7 +297,7 @@ def build_export_workbook(selected: list[str], ndigits: int = 2) -> tuple[bytes|
     if "Training_Metrics" in selected and res.get("m_train"):
         _add_sheet(sheets, order, "Training_Metrics", pd.DataFrame([res["m_train"]]), ndigits)
     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]
+        tr_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Train"].columns]
         _add_sheet(sheets, order, "Training_Summary", _summary_table(res["Train"], tr_cols), ndigits)
 
     # Testing
@@ -294,7 +306,7 @@ def build_export_workbook(selected: list[str], ndigits: int = 2) -> tuple[bytes|
     if "Testing_Metrics" in selected and res.get("m_test"):
         _add_sheet(sheets, order, "Testing_Metrics", pd.DataFrame([res["m_test"]]), ndigits)
     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]
+        te_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Test"].columns]
         _add_sheet(sheets, order, "Testing_Summary", _summary_table(res["Test"], te_cols), ndigits)
 
     # Validation
@@ -312,8 +324,6 @@ def build_export_workbook(selected: list[str], ndigits: int = 2) -> tuple[bytes|
         _add_sheet(sheets, order, "Prediction", res["PredictOnly"], ndigits)
     if "Prediction_Summary" in selected and res.get("sv_pred"):
         _add_sheet(sheets, order, "Prediction_Summary", pd.DataFrame([res["sv_pred"]]), ndigits)
-    if "Prediction_OOR" in selected and isinstance(res.get("oor_tbl_pred"), pd.DataFrame) and not res["oor_tbl_pred"].empty:
-        _add_sheet(sheets, order, "Prediction_OOR", res["oor_tbl_pred"].reset_index(drop=True), ndigits)
 
     # Training ranges
     if "Training_Ranges" in selected and st.session_state.get("train_ranges"):
@@ -323,79 +333,69 @@ def build_export_workbook(selected: list[str], ndigits: int = 2) -> tuple[bytes|
     # 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")},
+            {"Key": "AppName",    "Value": APP_NAME},
+            {"Key": "Tagline",    "Value": TAGLINE},
+            {"Key": "Target",     "Value": TARGET},
+            {"Key": "PredColumn", "Value": PRED_COL},
+            {"Key": "Features",   "Value": ", ".join(FEATURES)},
+            {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
         ])
         _add_sheet(sheets, order, "Info", info, ndigits)
 
     if not order:
         return None, None, []
 
-    # Write workbook to memory
     bio = io.BytesIO()
     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)
-            _excel_autofit(writer, _excel_safe_name(name), df)
+            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"
+    fname = f"YM_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:
     st.divider()
     st.markdown("### Export to Excel")
 
-    # Defaults: include everything that currently exists
     default_sections = _available_sections()
     all_sections = [
         "Training","Training_Metrics","Training_Summary",
         "Testing","Testing_Metrics","Testing_Summary",
         "Validation","Validation_Metrics","Validation_Summary","Validation_OOR",
-        "Prediction","Prediction_Summary","Prediction_OOR",
+        "Prediction","Prediction_Summary",
         "Training_Ranges","Info"
     ]
-    selected = st.multiselect(
-        "Sheets to include",
-        options=all_sections,
-        default=default_sections,
-        help="Choose which sheets to include in the Excel export."
-    )
-
-    c1, c2, c3 = st.columns([1,1,2])
+    selected = st.multiselect("Sheets to include", options=all_sections, default=default_sections)
+    c1, c2 = st.columns([1,2])
     with c1:
-        ndigits = st.number_input("Rounding (decimals)", min_value=0, max_value=6, value=2, step=1)
+        ndigits = st.number_input("Rounding (decimals)", 0, 6, 2, 1)
     with c2:
-        base_name = st.text_input("Base filename", value="GR_Export")
-    with c3:
-        st.caption("• Columns auto-fit & header row frozen (if xlsxwriter is available).")
-
-    data, default_fname, names = build_export_workbook(selected=selected, ndigits=int(ndigits))
+        base_name = st.text_input("Base filename", value="YM_Export")
 
+    data, _, names = build_export_workbook(selected=selected, ndigits=int(ndigits))
     if names:
         st.caption("Will include: " + ", ".join(names))
+
     st.download_button(
-        label="⬇️ Export Excel",
+        "⬇️ Export Excel",
         data=(data or b""),
-        file_name=((base_name or "GR_Export") + "_" + datetime.now().strftime("%Y%m%d_%H%M%S") + ".xlsx") if data else "GR_Export.xlsx",
+        file_name=((base_name or "YM_Export") + "_" + datetime.now().strftime("%Y%m%d_%H%M%S") + ".xlsx") if data else "YM_Export.xlsx",
         mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
         disabled=(data is None),
-        help="Exports selected sheets with optional rounding, auto-fit columns, and frozen headers.",
         key=key,
     )
+
 # =========================
 # Cross plot (Matplotlib) — auto-scaled for Ym
 # =========================
 def cross_plot_static(actual, pred, xlabel="Actual Ym", ylabel="Predicted Ym"):
     a = pd.Series(actual, dtype=float)
-    p = pd.Series(pred, dtype=float)
+    p = pd.Series(pred,   dtype=float)
 
     lo = float(min(a.min(), p.min()))
     hi = float(max(a.max(), p.max()))
@@ -416,7 +416,6 @@ def cross_plot_static(actual, pred, xlabel="Actual Ym", ylabel="Predicted Ym"):
     ax.set_yticks(ticks)
     ax.set_aspect("equal", adjustable="box")
 
-    # Generic numeric formatting (2 decimals)
     fmt = FuncFormatter(lambda x, _: f"{x:.2f}")
     ax.xaxis.set_major_formatter(fmt)
     ax.yaxis.set_major_formatter(fmt)
@@ -434,7 +433,7 @@ def cross_plot_static(actual, pred, xlabel="Actual Ym", ylabel="Predicted Ym"):
     return fig
 
 # =========================
-# Track plot (Plotly)
+# Track plot (Plotly) — x axis with NO decimals
 # =========================
 def track_plot(df, include_actual=True):
     # Depth (or index) on Y
@@ -463,20 +462,18 @@ def track_plot(df, include_actual=True):
             x=df[PRED_COL], y=y, mode="lines",
             line=dict(color=COLORS["pred"], width=1.8),
             name=PRED_COL,
-            hovertemplate=f"{PRED_COL}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
+            hovertemplate=f"{PRED_COL}: "+"%{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
         ))
     if include_actual and TARGET in df.columns:
         fig.add_trace(go.Scatter(
             x=df[TARGET], y=y, mode="lines",
             line=dict(color=COLORS["actual"], width=2.0, dash="dot"),
             name=f"{TARGET} (actual)",
-            hovertemplate=f"{TARGET}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
+            hovertemplate=f"{TARGET}: "+"%{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
-        height=TRACK_H,
-        width=TRACK_W,
-        autosize=False,
+        height=TRACK_H, width=TRACK_W, autosize=False,
         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"),
@@ -484,34 +481,24 @@ def track_plot(df, include_actual=True):
                     bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1),
         legend_title_text=""
     )
-
     fig.update_xaxes(
         title_text="Ym",
         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=",.2f",
-        tickmode="auto",
-        tick0=tick0,
+        side="top", range=[xmin, xmax],
+        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
     )
-  
-    fig.update_xaxes(
-        title_text="Ym",
+    fig.update_yaxes(
+        title_text=ylab,
         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",  # ← integer, thousands separated, no decimals
-        tickmode="auto",
-        tick0=tick0,
+        range=y_range, ticks="outside",
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
+
     return fig
 
 # ---------- Preview modal (matplotlib) ----------
@@ -523,17 +510,18 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
         ax.text(0.5,0.5,"No selected columns",ha="center",va="center"); ax.axis("off")
         return fig
     fig, axes = plt.subplots(1, n, figsize=(2.2*n, 7.0), sharey=True, dpi=100)
-    if n == 1: axes = [axes]
+    if n == 1: 
+        axes = [axes]
     idx = np.arange(1, len(df) + 1)
     for ax, col in zip(axes, cols):
-        ax.plot(df[col], idx, '-', lw=1.4, color="#333")
+        ax.plot(pd.to_numeric(df[col], errors="coerce"), idx, '-', lw=1.4, color="#333")
         ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
         ax.grid(True, linestyle=":", alpha=0.3)
         for s in ax.spines.values(): s.set_visible(True)
     axes[0].set_ylabel("Point Index")
     return fig
 
-# Modal wrapper
+# Modal wrapper (Streamlit compatibility)
 try:
     dialog = st.dialog
 except AttributeError:
@@ -557,19 +545,28 @@ def preview_modal(book: dict[str, pd.DataFrame]):
             with t1:
                 st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)
             with t2:
-                tbl = (df[FEATURES]
-                        .agg(['min','max','mean','std'])
-                        .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}))
-                df_centered_rounded(tbl.reset_index(names="Feature"))
+                feat_present = [c for c in FEATURES if c in df.columns]
+                if not feat_present:
+                    st.info("No feature columns found to summarize.")
+                else:
+                    tbl = (
+                        df[feat_present]
+                          .agg(['min','max','mean','std'])
+                          .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
+                          .reset_index(names="Feature")
+                    )
+                    df_centered_rounded(tbl)
 
 # =========================
-# Load model
+# Load model + meta
 # =========================
 def ensure_model() -> Path|None:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
-        if p.exists() and p.stat().st_size > 0: return p
+        if p.exists() and p.stat().st_size > 0:
+            return p
     url = os.environ.get("MODEL_URL", "")
-    if not url: return None
+    if not url:
+        return None
     try:
         import requests
         DEFAULT_MODEL.parent.mkdir(parents=True, exist_ok=True)
@@ -577,7 +574,8 @@ 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
@@ -592,25 +590,24 @@ except Exception as e:
     st.error(f"Failed to load model: {e}")
     st.stop()
 
-# ---------- Load meta (optional) ----------
-meta = {}  # define first, so it's always safe to reference later
-
-# Support either models/meta.json or models/ym_meta.json
-meta_candidates = [MODELS_DIR / "meta.json", MODELS_DIR / "ym_meta.json"]
-meta_path = next((p for p in meta_candidates if p.exists()), None)
-
-if meta_path:
-    try:
-        meta = json.loads(meta_path.read_text(encoding="utf-8"))
-        FEATURES = meta.get("features", FEATURES)
-        TARGET = meta.get("target", TARGET)
-    except Exception as e:
-        st.warning(f"Could not parse meta file ({meta_path.name}): {e}")
-
-# ---------- Optional: warn if runtime != training versions ----------
-import numpy as _np, sklearn as _skl
-mv = meta.get("versions", {})
-if mv:
+# Load meta (optional): support models/meta.json or models/ym_meta.json
+meta = {}
+for cand in [MODELS_DIR / "meta.json", MODELS_DIR / "ym_meta.json"]:
+    if cand.exists():
+        try:
+            meta = json.loads(cand.read_text(encoding="utf-8"))
+            break
+        except Exception:
+            pass
+
+if meta:
+    FEATURES = meta.get("features", FEATURES)
+    TARGET   = meta.get("target", TARGET)
+
+# Warn if runtime != training versions
+try:
+    import numpy as _np, sklearn as _skl
+    mv = meta.get("versions", {}) if isinstance(meta, dict) else {}
     msg = []
     if mv.get("numpy") and mv["numpy"] != _np.__version__:
         msg.append(f"NumPy {mv['numpy']} expected, running {_np.__version__}")
@@ -618,7 +615,8 @@ if mv:
         msg.append(f"scikit-learn {mv['scikit_learn']} expected, running {_skl.__version__}")
     if msg:
         st.warning("Environment mismatch: " + " | ".join(msg))
-
+except Exception:
+    pass
 
 # =========================
 # Session state
@@ -638,14 +636,14 @@ st.session_state.setdefault("show_preview_modal", False)
 st.sidebar.markdown(f"""
     <div class="centered-container">
         <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-        <div style='font-weight:800;font-size:1.2rem;'>ST_GeoMech_YM</div>
-        <div style='color:#667085;'>Real-Time Young's Modulus Tracking</div>
+        <div style='font-weight:800;font-size:1.2rem;'>{APP_NAME}</div>
+        <div style='color:#667085;'>{TAGLINE}</div>
     </div>
     """, unsafe_allow_html=True
 )
 
 # =========================
-# Reusable Sticky Header Function
+# Reusable Sticky Header
 # =========================
 def sticky_header(title, message):
     st.markdown(
@@ -672,8 +670,8 @@ if st.session_state.app_step == "intro":
     st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate Young's Modulus (Ym) from drilling data.")
     st.subheader("How It Works")
     st.markdown(
-        "1) **Upload your data to build the case and preview the model performance.** \n"
-        "2) Click **Run Model** to compute metrics and plots. \n"
+        "1) **Upload your data to build the case and preview the model performance.**  \n"
+        "2) Click **Run Model** to compute metrics and plots.  \n"
         "3) **Proceed to Validation** (with actual Ym) or **Proceed to Prediction** (no Ym)."
     )
     if st.button("Start Showcase", type="primary"):
@@ -682,13 +680,6 @@ if st.session_state.app_step == "intro":
 # =========================
 # CASE BUILDING
 # =========================
-def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
-    out = df.copy()
-    out.columns = [c.strip() for c in out.columns]
-    # Fix flow-rate typo variants
-    out = out.rename(columns={"Fow Rate, gpm": "Flow Rate, gpm", "Fow Rate, gpm ": "Flow Rate, gpm"})
-    return out
-
 if st.session_state.app_step == "dev":
     st.sidebar.header("Case Building")
     up = st.sidebar.file_uploader("Upload Your Data File", type=["xlsx","xls"])
@@ -708,8 +699,10 @@ 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()
 
     if st.session_state.dev_file_loaded and st.session_state.dev_preview:
         sticky_header("Case Building", "Previewed ✓ — now click **Run Model**.")
@@ -728,7 +721,6 @@ if st.session_state.app_step == "dev":
         tr = _normalize_columns(book[sh_train].copy())
         te = _normalize_columns(book[sh_test].copy())
 
-        # Depth is allowed but not required
         if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])):
             st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True)
             st.stop()
@@ -784,7 +776,7 @@ if st.session_state.app_step == "dev":
         if "Train" in st.session_state.results:
             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"])
 
 # =========================
 # VALIDATION (with actual Ym)
@@ -800,8 +792,10 @@ 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 **Actual Ym** to evaluate performance.")
 
@@ -809,8 +803,9 @@ if st.session_state.app_step == "validate":
         book = read_book_bytes(up.getvalue())
         name = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
         df = _normalize_columns(book[name].copy())
-        if not ensure_cols(df, FEATURES+[TARGET]): 
+        if not ensure_cols(df, FEATURES+[TARGET]):
             st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
+
         df[PRED_COL] = model.predict(df[FEATURES])
         st.session_state.results["Validate"]=df
 
@@ -861,7 +856,8 @@ if st.session_state.app_step == "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"])
@@ -880,14 +876,15 @@ 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
     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()
+    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 **Actual Ym**).")
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
         df = _normalize_columns(book[name].copy())
-        if not ensure_cols(df, FEATURES): 
+        if not ensure_cols(df, FEATURES):
             st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
         df[PRED_COL] = model.predict(df[FEATURES])
         st.session_state.results["PredictOnly"]=df
@@ -930,10 +927,9 @@ if st.session_state.app_step == "predict":
             )
 
 # =========================
-# Run preview modal after all other elements
+# Preview modal (re-usable)
 # =========================
 if st.session_state.show_preview_modal:
-    # Select the correct workbook bytes for this step
     book_to_preview = {}
     if st.session_state.app_step == "dev":
         book_to_preview = read_book_bytes(st.session_state.dev_file_bytes)
@@ -948,16 +944,10 @@ if st.session_state.show_preview_modal:
             tabs = st.tabs(names)
             for t, name in zip(tabs, names):
                 with t:
-                    # 🔧 Normalize columns BEFORE plotting/summarizing
-                    df_raw = book_to_preview[name]
-                    df = _normalize_columns(df_raw)
-
-                    # Tracks
+                    df = _normalize_columns(book_to_preview[name])
                     t1, t2 = st.tabs(["Tracks", "Summary"])
                     with t1:
                         st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)
-
-                    # Summary (guard against any missing cols after normalization)
                     with t2:
                         feat_present = [c for c in FEATURES if c in df.columns]
                         if not feat_present:
@@ -970,10 +960,13 @@ if st.session_state.show_preview_modal:
                                   .reset_index(names="Feature")
                             )
                             df_centered_rounded(tbl)
-
-    # Reset the flag so the modal doesn't stick around
     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
@@ -985,4 +978,4 @@ st.markdown("""
     © 2025 Smart Thinking AI-Solutions Team. All rights reserved.<br>
     Website: <a href="https://smartthinking.com.sa" target="_blank" rel="noopener noreferrer">smartthinking.com.sa</a>
 </div>
-""", unsafe_allow_html=True)
+""", unsafe_allow_html=True)