Update app.py

app.py

@@ -1,21 +1,19 @@
-# app.py — ST_GeoMech_SMW (final, simplified & robust)
-
+# app.py — ST_GeoMech_SMW (pcf version, robust IO + aliases)
 import io, json, os, base64, math
 from pathlib import Path
-from datetime import datetime
-
 import streamlit as st
 import pandas as pd
 import numpy as np
 import joblib
+from datetime import datetime
 
-# plotting
+# Matplotlib (static)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 from matplotlib.ticker import FuncFormatter
-import plotly.graph_objects as go
 
+import plotly.graph_objects as go
 from sklearn.metrics import mean_squared_error, mean_absolute_error
 
 # =========================
@@ -24,15 +22,31 @@ from sklearn.metrics import mean_squared_error, mean_absolute_error
 APP_NAME = "ST_GeoMech_SMW"
 TAGLINE  = "Real-Time Upper/Lower Mud Weight (MW) Limits For Safe Drilling"
 
-MODELS_DIR = Path("models")
-BO_MODEL_PATH = MODELS_DIR / "bo_model.joblib"
-BD_MODEL_PATH = MODELS_DIR / "bd_model.joblib"
-BO_META_PATH  = MODELS_DIR / "bo_meta.json"
-BD_META_PATH  = MODELS_DIR / "bd_meta.json"
+# Defaults (can be overridden by metas or model.feature_names_in_)
+FEATURES_DEFAULT = [
+    "WOB (klbf)",
+    "Torque (kft.lbf)",
+    "SPP (psi)",
+    "RPM (1/min)",
+    "ROP (ft/h)",
+    "Flow Rate (gpm)",
+]
 
+TARGET_BO_DEFAULT = "Breakout MW"
+TARGET_BD_DEFAULT = "Breakdown MW"
 PRED_BO = "BO_Pred"
 PRED_BD = "BD_Pred"
-X_UNITS = "MW (pcf)"  # your metas use pcf units
+
+# X-axis title for MW tracks/cross-plots (unit taken from metas, fallback to pcf)
+X_UNITS = None
+
+# Model/meta discovery (supports uploads with spaces like "bo_model (1).joblib")
+MODELS_DIR = Path("models")
+ALT_MODELS_DIR = Path("/mnt/data")
+BO_MODEL_CANDIDATES = ["bo_model.joblib", "bo_model (1).joblib", "BO.joblib"]
+BD_MODEL_CANDIDATES = ["bd_model.joblib", "BD.joblib"]
+BO_META_CANDIDATES  = ["bo_meta.json", "bo_meta (1).json"]
+BD_META_CANDIDATES  = ["bd_meta.json"]
 
 COLORS = {
     "pred_bo": "#1f77b4",  # blue
@@ -42,21 +56,23 @@ COLORS = {
     "ref": "#5a5a5a"
 }
 
+STRICT_VERSION_CHECK = False
+
 # Plot sizing
-CROSS_W = 360
-CROSS_H = 360
-TRACK_H = 900
-TRACK_W = 480
+CROSS_W = 350
+CROSS_H = 350
+TRACK_H = 1000
+TRACK_W = 500
 FONT_SZ = 13
 BOLD_FONT = "Arial Black, Arial, sans-serif"
 
 # =========================
 # Page / CSS
 # =========================
-st.set_page_config(page_title=APP_NAME, page_icon="🛢️", layout="wide")
+st.set_page_config(page_title=APP_NAME, page_icon="logo.png", layout="wide")
 st.markdown("""
 <style>
- .brand-logo { width: 180px; height: auto; object-fit: contain; }
+ .brand-logo { width: 200px; height: auto; object-fit: contain; }
  .centered-container { display:flex; flex-direction:column; align-items:center; text-align:center; }
  .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; }
@@ -64,6 +80,12 @@ st.markdown("""
  .st-message-box.st-error   { background:#f8d7da; color:#721c24; border-color:#f5c6cb; }
  .main .block-container { overflow: unset !important; }
  div[data-testid="stVerticalBlock"] { overflow: unset !important; }
+ 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)
 
@@ -72,6 +94,49 @@ TABLE_CENTER_CSS = [
     dict(selector="td", props=[("text-align","center")]),
 ]
 
+# =========================
+# Password gate
+# =========================
+def inline_logo(path="logo.png") -> str:
+    try:
+        p = Path(path)
+        if not p.exists(): return ""
+        return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
+    except Exception:
+        return ""
+
+def add_password_gate() -> None:
+    try:
+        required = st.secrets.get("APP_PASSWORD", "")
+    except Exception:
+        required = os.environ.get("APP_PASSWORD", "")
+
+    if not required:
+        st.warning("Set APP_PASSWORD in Secrets (or environment) and restart.")
+        st.stop()
+
+    if st.session_state.get("auth_ok", False):
+        return
+
+    st.sidebar.markdown(f"""
+        <div class="centered-container">
+            <img src="{inline_logo('logo.png')}" class="brand-logo">
+            <div style='font-weight:800;font-size:1.2rem; margin-top:10px;'>{APP_NAME}</div>
+            <div style='color:#667085;'>Smart Thinking • Secure Access</div>
+        </div>
+        """, unsafe_allow_html=True
+    )
+    pwd = st.sidebar.text_input("Access key", type="password", placeholder="••••••••")
+    if st.sidebar.button("Unlock", type="primary"):
+        if pwd == required:
+            st.session_state.auth_ok = True
+            st.rerun()
+        else:
+            st.error("Incorrect key.")
+    st.stop()
+
+add_password_gate()
+
 # =========================
 # Utilities
 # =========================
@@ -95,6 +160,9 @@ 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 _nice_tick0(xmin: float, step: float = 0.1) -> float:
     return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
 
@@ -118,35 +186,45 @@ def _make_X(df: pd.DataFrame, features: list[str]) -> pd.DataFrame:
 
 # ---- Column name normalization (aliases) ----
 def _build_alias_map(canonical_features: list[str], tgt_bo: str, tgt_bd: str) -> dict:
-    # canonical list comes from metas or model.feature_names_in_
     def pick(expected_list, variants):
         for v in variants:
             if v in expected_list:
                 return v
         return variants[0]
 
-    can_Q      = pick(canonical_features, ["Q, gpm", "Flow Rate (gpm)", "Flow Rate, gpm", "Flow Rate , gpm", "Flow Rate,gpm"])
-    can_SPP    = pick(canonical_features, ["SPP(psi)", "SPP (psi)"])
-    can_TORQUE = pick(canonical_features, ["T (kft.lbf)", "Torque (kft.lbf)", "Torque(kft.lbf)", "TORQUE(kft.lbf)"])
+    # Canonical picks from what the model actually expects
     can_WOB    = pick(canonical_features, ["WOB (klbf)", "WOB, klbf", "WOB(klbf)", "WOB( klbf)"])
+    can_TORQUE = pick(canonical_features, ["Torque (kft.lbf)", "Torque(kft.lbf)", "TORQUE(kft.lbf)", "T (kft.lbf)"])  # include "T (kft.lbf)"
+    can_SPP    = pick(canonical_features, ["SPP (psi)", "SPP(psi)"])
+    can_RPM    = pick(canonical_features, ["RPM (1/min)", "RPM(1/min)"])
     can_ROP    = pick(canonical_features, ["ROP (ft/h)", "ROP(ft/h)"])
+    can_FR     = pick(canonical_features, [
+        "Flow Rate (gpm)", "Flow Rate, gpm", "Flow Rate,gpm", "Flow Rate , gpm",
+        "Q, gpm"  # include meta/training alias
+    ])
 
-    alias = {
-        # Flow
-        "Q, gpm": can_Q, "Flow Rate (gpm)": can_Q, "Flow Rate, gpm": can_Q, "Flow Rate , gpm": can_Q, "Flow Rate,gpm": can_Q,
-        # SPP
-        "SPP(psi)": can_SPP, "SPP (psi)": can_SPP,
-        # Torque
-        "T (kft.lbf)": can_TORQUE, "Torque (kft.lbf)": can_TORQUE, "Torque(kft.lbf)": can_TORQUE, "TORQUE(kft.lbf)": can_TORQUE,
+    # Depth canonical = whatever is in training FEATURES (Depth or Depth (ft), etc.)
+    can_DEPTH  = pick(canonical_features, ["Depth", "Depth (ft)", "Depth, ft", "Depth(ft)", "DEPTH, ft"])
+
+    return {
         # WOB
         "WOB (klbf)": can_WOB, "WOB, klbf": can_WOB, "WOB(klbf)": can_WOB, "WOB( klbf)": can_WOB,
+        # Torque / T
+        "Torque (kft.lbf)": can_TORQUE, "Torque(kft.lbf)": can_TORQUE, "TORQUE(kft.lbf)": can_TORQUE, "T (kft.lbf)": can_TORQUE,
+        # SPP
+        "SPP (psi)": can_SPP, "SPP(psi)": can_SPP,
+        # RPM
+        "RPM (1/min)": can_RPM, "RPM(1/min)": can_RPM,
         # ROP
         "ROP (ft/h)": can_ROP, "ROP(ft/h)": can_ROP,
-        # Targets (accept common variants as well)
-        "BO_Actual": tgt_bo, "Breakout MW": tgt_bo, "BOMW": tgt_bo, "BO MW": tgt_bo,
-        "BD_Actual": tgt_bd, "Breakdown MW": tgt_bd, "BDMW": tgt_bd, "BD MW": tgt_bd,
+        # Flow / Q
+        "Flow Rate (gpm)": can_FR, "Flow Rate, gpm": can_FR, "Flow Rate,gpm": can_FR, "Flow Rate , gpm": can_FR, "Q, gpm": can_FR,
+        # Depth
+        "Depth": can_DEPTH, "Depth (ft)": can_DEPTH, "Depth, ft": can_DEPTH, "Depth(ft)": can_DEPTH, "DEPTH, ft": can_DEPTH,
+        # Targets (accept extra common names)
+        "Breakout MW": tgt_bo, "BOMW": tgt_bo, "BO MW": tgt_bo, "BO_Actual": tgt_bo,
+        "Breakdown MW": tgt_bd, "BDMW": tgt_bd, "BD MW": tgt_bd, "BD_Actual": tgt_bd,
     }
-    return alias
 
 DEPTH_CANDIDATES = ["Depth", "Depth (ft)", "Depth, ft", "Depth(ft)", "DEPTH, ft"]
 
@@ -157,42 +235,244 @@ def _normalize_columns(df: pd.DataFrame, canonical_features: list[str], tgt_bo:
     actual = {k: v for k, v in alias.items() if k in out.columns and k != v}
     return out.rename(columns=actual)
 
-def _depth_series(df):
-    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
-    if depth_col is not None:
-        y = pd.to_numeric(df[depth_col], errors="coerce"); ylab = depth_col
-        rng = [float(y.max()), float(y.min())]  # reversed
-    else:
-        y = pd.Series(np.arange(1, len(df) + 1)); ylab = "Point Index"
-        rng = [float(y.max()), float(y.min())]
-    return y, ylab, rng
+def _coerce_depth(df: pd.DataFrame, canon_depth: str | None) -> pd.DataFrame:
+    """If the model expects a Depth-like column, rename any variant to it."""
+    if not canon_depth:
+        return df
+    if canon_depth in df.columns:
+        return df
+    for c in DEPTH_CANDIDATES:
+        if c in df.columns:
+            return df.rename(columns={c: canon_depth})
+    return df
+
+def _prepare_table(raw_df: pd.DataFrame, stage: str, features: list[str],
+                   tgt_bo: str, tgt_bd: str, canon_depth: str | None) -> pd.DataFrame:
+    """Normalize headers, coerce depth name, and validate required columns."""
+    df = _normalize_columns(raw_df, features, tgt_bo, tgt_bd)
+    df = _coerce_depth(df, canon_depth)
+    missing = [c for c in features if c not in df.columns]
+    if missing:
+        st.error(
+            f"{stage}: Missing required column(s): {missing}\n\n"
+            f"Found columns: {list(df.columns)}\n\n"
+            f"Expected features: {features}"
+        )
+        st.stop()
+    return df
+
+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)}")
+        return False
+    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()]
+    return None
+
+# === Excel export helpers =================================================
+def _excel_engine() -> str:
+    try:
+        import xlsxwriter  # noqa: F401
+        return "xlsxwriter"
+    except Exception:
+        return "openpyxl"
+
+def _excel_safe_name(name: str) -> str:
+    bad = '[]:*?/\\'
+    safe = ''.join('_' if ch in bad else ch for ch in str(name))
+    return safe[:31]
+
+def _round_numeric(df: pd.DataFrame, ndigits: int = 3) -> pd.DataFrame:
+    out = df.copy()
+    for c in out.columns:
+        if pd.api.types.is_float_dtype(out[c]) or pd.api.types.is_integer_dtype(out[c]):
+            out[c] = pd.to_numeric(out[c], errors="coerce").round(ndigits)
+    return out
 
-def _x_range_for_tracks(df, cols):
-    x_series = pd.concat([pd.to_numeric(df[c], errors="coerce") for c in cols if c in df], ignore_index=True)
-    x_lo, x_hi = float(x_series.min()), float(x_series.max())
-    pad = 0.03 * (x_hi - x_lo if x_hi > x_lo else 1.0)
-    xmin, xmax = x_lo - pad, x_hi + pad
-    tick0 = _nice_tick0(xmin, step=max((xmax - xmin)/10.0, 0.1))
-    return xmin, xmax, tick0
+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 _round_numeric(tbl, 3)
+
+def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
+    if not ranges:
+        return pd.DataFrame()
+    df = pd.DataFrame(ranges).T.reset_index()
+    df.columns = ["Feature", "Min", "Max"]
+    return _round_numeric(df, 3)
+
+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 _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)
+
+def _available_sections() -> list[str]:
+    res = st.session_state.get("results", {})
+    sections = []
+    if "Train" in res:        sections += ["Training","Training_Metrics_BO","Training_Metrics_BD","Training_Summary"]
+    if "Test" in res:         sections += ["Testing","Testing_Metrics_BO","Testing_Metrics_BD","Testing_Summary"]
+    if "Validate" in res:     sections += ["Validation","Validation_Metrics_BO","Validation_Metrics_BD","Validation_Summary","Validation_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 = 3, 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] = []
+
+    if "Training" in selected and "Train" in res:
+        _add_sheet(sheets, order, "Training", res["Train"], ndigits)
+    if "Training_Metrics_BO" in selected and res.get("m_train_bo"):
+        _add_sheet(sheets, order, "Training_Metrics_BO", pd.DataFrame([res["m_train_bo"]]), ndigits)
+    if "Training_Metrics_BD" in selected and res.get("m_train_bd"):
+        _add_sheet(sheets, order, "Training_Metrics_BD", pd.DataFrame([res["m_train_bd"]]), ndigits)
+    if "Training_Summary" in selected and "Train" in res:
+        tr_cols = st.session_state["FEATURES"] + [c for c in [st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], PRED_BO, PRED_BD] if c in res["Train"].columns]
+        _add_sheet(sheets, order, "Training_Summary", _summary_table(res["Train"], tr_cols), ndigits)
+
+    if "Testing" in selected and "Test" in res:
+        _add_sheet(sheets, order, "Testing", res["Test"], ndigits)
+    if "Testing_Metrics_BO" in selected and res.get("m_test_bo"):
+        _add_sheet(sheets, order, "Testing_Metrics_BO", pd.DataFrame([res["m_test_bo"]]), ndigits)
+    if "Testing_Metrics_BD" in selected and res.get("m_test_bd"):
+        _add_sheet(sheets, order, "Testing_Metrics_BD", pd.DataFrame([res["m_test_bd"]]), ndigits)
+    if "Testing_Summary" in selected and "Test" in res:
+        te_cols = st.session_state["FEATURES"] + [c for c in [st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], PRED_BO, PRED_BD] if c in res["Test"].columns]
+        _add_sheet(sheets, order, "Testing_Summary", _summary_table(res["Test"], te_cols), ndigits)
+
+    if "Validation" in selected and "Validate" in res:
+        _add_sheet(sheets, order, "Validation", res["Validate"], ndigits)
+    if "Validation_Metrics_BO" in selected and res.get("m_val_bo"):
+        _add_sheet(sheets, order, "Validation_Metrics_BO", pd.DataFrame([res["m_val_bo"]]), ndigits)
+    if "Validation_Metrics_BD" in selected and res.get("m_val_bd"):
+        _add_sheet(sheets, order, "Validation_Metrics_BD", pd.DataFrame([res["m_val_bd"]]), ndigits)
+    if "Validation_Summary" in selected and res.get("sv_val"):
+        _add_sheet(sheets, order, "Validation_Summary", pd.DataFrame([res["sv_val"]]), ndigits)
+    if "Validation_OOR" in selected and isinstance(res.get("oor_tbl"), pd.DataFrame) and not res["oor_tbl"].empty:
+        _add_sheet(sheets, order, "Validation_OOR", res["oor_tbl"].reset_index(drop=True), ndigits)
+
+    if "Prediction" in selected and "PredictOnly" in res:
+        _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 "Training_Ranges" in selected and st.session_state.get("train_ranges"):
+        rr = _train_ranges_df(st.session_state["train_ranges"])
+        _add_sheet(sheets, order, "Training_Ranges", rr, ndigits)
+
+    if "Info" in selected:
+        info = pd.DataFrame([
+            {"Key": "AppName",    "Value": APP_NAME},
+            {"Key": "Tagline",    "Value": TAGLINE},
+            {"Key": "Targets",    "Value": f'{st.session_state["TARGET_BO"]}, {st.session_state["TARGET_BD"]}'},
+            {"Key": "PredColumns","Value": f'{PRED_BO}, {PRED_BD}'},
+            {"Key": "Features",   "Value": ", ".join(st.session_state["FEATURES"])},
+            {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
+            {"Key": "Units",      "Value": st.session_state.get("X_UNITS","MW (pcf)")},
+        ])
+        _add_sheet(sheets, order, "Info", info, ndigits)
+
+    if not order: return None, None, []
+
+    bio = io.BytesIO()
+    engine = _excel_engine()
+    with pd.ExcelWriter(bio, engine=engine) as writer:
+        for name in order:
+            df = sheets[name]
+            sheet = _excel_safe_name(name)
+            df.to_excel(writer, sheet_name=sheet, index=False)
+            if do_autofit:
+                _excel_autofit(writer, sheet, df)
+    bio.seek(0)
+    fname = f"MW_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+    return bio.getvalue(), fname, order
+
+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)",
+        key=f"sheets_{phase_key}",
+    )
+
+    if not selected_sheets:
+        st.caption("Select one or more sheets above to enable the export.")
+        st.download_button(
+            label="⬇️ Export Excel",
+            data=b"",
+            file_name="MW_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=3, do_autofit=True)
+    if names:
+        st.caption("Will include: " + ", ".join(names))
+    st.download_button(
+        "⬇️ Export Excel",
+        data=(data or b""),
+        file_name=(fname or "MW_Export.xlsx"),
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        disabled=(data is None),
+        key=f"download_{phase_key}",
+    )
 
 # =========================
-# Plots
+# Cross plots (Matplotlib)
 # =========================
 def cross_plot_static(actual, pred, xlabel, ylabel, color="#1f77b4"):
     a = pd.Series(actual, dtype=float)
     p = pd.Series(pred, dtype=float)
+
     lo = float(min(a.min(), p.min()))
     hi = float(max(a.max(), p.max()))
     pad = 0.03 * (hi - lo if hi > lo else 1.0)
     lo2, hi2 = lo - pad, hi + pad
     ticks = np.linspace(lo2, hi2, 5)
+
     dpi = 110
     fig, ax = plt.subplots(figsize=(CROSS_W/dpi, CROSS_H/dpi), dpi=dpi, constrained_layout=False)
     ax.scatter(a, p, s=14, c=color, alpha=0.9, linewidths=0)
     ax.plot([lo2, hi2], [lo2, hi2], linestyle="--", linewidth=1.2, color=COLORS["ref"])
+
     ax.set_xlim(lo2, hi2); ax.set_ylim(lo2, hi2)
     ax.set_xticks(ticks); ax.set_yticks(ticks)
     ax.set_aspect("equal", adjustable="box")
+
     fmt = FuncFormatter(lambda x, _: f"{x:.2f}")
     ax.xaxis.set_major_formatter(fmt); ax.yaxis.set_major_formatter(fmt)
     ax.set_xlabel(xlabel, fontweight="bold", fontsize=10, color="black")
@@ -203,10 +483,32 @@ def cross_plot_static(actual, pred, xlabel, ylabel, color="#1f77b4"):
     fig.subplots_adjust(left=0.16, bottom=0.16, right=0.98, top=0.98)
     return fig
 
+# =========================
+# Track plots (Plotly)
+# =========================
+def _depth_series(df):
+    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
+    if depth_col is not None:
+        y = pd.to_numeric(df[depth_col], errors="coerce"); ylab = depth_col
+        rng = [float(y.max()), float(y.min())]  # reversed
+    else:
+        y = pd.Series(np.arange(1, len(df) + 1)); ylab = "Point Index"
+        rng = [float(y.max()), float(y.min())]
+    return y, ylab, rng
+
+def _x_range_for_tracks(df, cols):
+    x_series = pd.concat([pd.to_numeric(df[c], errors="coerce") for c in cols if c in df], ignore_index=True)
+    x_lo, x_hi = float(x_series.min()), float(x_series.max())
+    pad = 0.03 * (x_hi - x_lo if x_hi > x_lo else 1.0)
+    xmin, xmax = x_lo - pad, x_hi + pad
+    tick0 = _nice_tick0(xmin, step=max((xmax - xmin)/10.0, 0.1))
+    return xmin, xmax, tick0
+
 def track_plot_single(df, pred_col, actual_col=None, title_suffix=""):
     y, ylab, y_range = _depth_series(df)
     cols = [pred_col] + ([actual_col] if actual_col and actual_col in df.columns else [])
     xmin, xmax, tick0 = _x_range_for_tracks(df, cols)
+
     fig = go.Figure()
     if pred_col in df.columns:
         fig.add_trace(go.Scatter(
@@ -218,11 +520,13 @@ def track_plot_single(df, pred_col, actual_col=None, title_suffix=""):
     if actual_col and actual_col in df.columns:
         fig.add_trace(go.Scatter(
             x=df[actual_col], y=y, mode="lines",
-            line=dict(color=COLORS["actual_bo"] if actual_col.lower().startswith("bo") else COLORS["actual_bd"],
+            line=dict(color=COLORS["actual_bo"] if actual_col==st.session_state["TARGET_BO"] else COLORS["actual_bd"],
                       width=2.0, dash="dot"),
             name=f"{actual_col} (actual)",
             hovertemplate=f"{actual_col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
         ))
+
+    title_text = st.session_state.get("X_UNITS", "MW (pcf)")
     fig.update_layout(
         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",
@@ -233,7 +537,7 @@ def track_plot_single(df, pred_col, actual_col=None, title_suffix=""):
         title=title_suffix
     )
     fig.update_xaxes(
-        title_text=X_UNITS, title_font=dict(size=20, family=BOLD_FONT, color="#000"),
+        title_text=title_text, 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,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
@@ -247,23 +551,34 @@ def track_plot_single(df, pred_col, actual_col=None, title_suffix=""):
     )
     return fig
 
-def track_plot_combined(df, target_bo, target_bd):
+def track_plot_combined(df):
+    """Overlay BO & BD predictions (+ actuals if present) on same depth axis."""
     y, ylab, y_range = _depth_series(df)
-    cols = [c for c in [PRED_BO, PRED_BD, target_bo, target_bd] if c in df]
+    cols = [c for c in [PRED_BO, PRED_BD, st.session_state["TARGET_BO"], st.session_state["TARGET_BD"]] if c in df]
     xmin, xmax, tick0 = _x_range_for_tracks(df, cols)
     fig = go.Figure()
+
     if PRED_BO in df.columns:
         fig.add_trace(go.Scatter(x=df[PRED_BO], y=y, mode="lines",
-            line=dict(color=COLORS["pred_bo"], width=1.8), name=PRED_BO))
-    if target_bo in df.columns:
-        fig.add_trace(go.Scatter(x=df[target_bo], y=y, mode="lines",
-            line=dict(color=COLORS["actual_bo"], width=2.0, dash="dot"), name=f"{target_bo} (actual)"))
+            line=dict(color=COLORS["pred_bo"], width=1.8), name=PRED_BO,
+            hovertemplate=f"{PRED_BO}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+    if st.session_state["TARGET_BO"] in df.columns:
+        col = st.session_state["TARGET_BO"]
+        fig.add_trace(go.Scatter(x=df[col], y=y, mode="lines",
+            line=dict(color=COLORS["actual_bo"], width=2.0, dash="dot"), name=f"{col} (actual)",
+            hovertemplate=f"{col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+
     if PRED_BD in df.columns:
         fig.add_trace(go.Scatter(x=df[PRED_BD], y=y, mode="lines",
-            line=dict(color=COLORS["pred_bd"], width=1.8), name=PRED_BD))
-    if target_bd in df.columns:
-        fig.add_trace(go.Scatter(x=df[target_bd], y=y, mode="lines",
-            line=dict(color=COLORS["actual_bd"], width=2.0, dash="dot"), name=f"{target_bd} (actual)"))
+            line=dict(color=COLORS["pred_bd"], width=1.8), name=PRED_BD,
+            hovertemplate=f"{PRED_BD}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+    if st.session_state["TARGET_BD"] in df.columns:
+        col = st.session_state["TARGET_BD"]
+        fig.add_trace(go.Scatter(x=df[col], y=y, mode="lines",
+            line=dict(color=COLORS["actual_bd"], width=2.0, dash="dot"), name=f"{col} (actual)",
+            hovertemplate=f"{col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+
+    title_text = st.session_state.get("X_UNITS", "MW (pcf)")
     fig.update_layout(
         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",
@@ -272,15 +587,19 @@ def track_plot_combined(df, target_bo, target_bd):
                     bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1),
         legend_title_text="", title="Combined (Breakout / Breakdown)"
     )
-    fig.update_xaxes(title_text=X_UNITS, side="top", range=[xmin, xmax],
-                     ticks="outside", tickformat=",.2f", tickmode="auto", tick0=tick0,
+    fig.update_xaxes(title_text=title_text, 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,
                      showline=True, linewidth=1.2, linecolor="#444", mirror=True,
                      showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True)
-    fig.update_yaxes(title_text=ylab, 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)
+    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"),
+                     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 (matplotlib) ----------
 def preview_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
@@ -288,11 +607,13 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
         fig, ax = plt.subplots(figsize=(4, 2))
         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:
         idx = pd.to_numeric(df[depth_col], errors="coerce"); y_label = depth_col
     else:
         idx = pd.Series(np.arange(1, len(df) + 1)); y_label = "Point Index"
+
     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)
@@ -314,53 +635,112 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
 def _ensure_file(p: Path) -> Path|None:
     return p if (p.exists() and p.stat().st_size > 0) else None
 
-bo_model_path = _ensure_file(BO_MODEL_PATH)
-bd_model_path = _ensure_file(BD_MODEL_PATH)
+def _first_existing(*paths: Path) -> Path|None:
+    for p in paths:
+        if _ensure_file(p): return p
+    return None
+
+def _find_in_dirs(names: list[str], *dirs: Path) -> Path|None:
+    for d in dirs:
+        for nm in names:
+            p = d / nm
+            if _ensure_file(p): return p
+    return None
+
+def _load_meta(p: Path) -> dict:
+    if not p or not p.exists(): return {}
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+bo_model_path = _find_in_dirs(BO_MODEL_CANDIDATES, MODELS_DIR, ALT_MODELS_DIR)
+bd_model_path = _find_in_dirs(BD_MODEL_CANDIDATES, MODELS_DIR, ALT_MODELS_DIR)
+bo_meta_path  = _find_in_dirs(BO_META_CANDIDATES,  MODELS_DIR, ALT_MODELS_DIR)
+bd_meta_path  = _find_in_dirs(BD_META_CANDIDATES,  MODELS_DIR, ALT_MODELS_DIR)
+
 if not (bo_model_path and bd_model_path):
-    st.error("Models not found. Place bo_model.joblib and bd_model.joblib in models/"); st.stop()
+    st.error("Models not found. Place bo_model.joblib and bd_model.joblib in models/ or upload to /mnt/data/.")
+    st.stop()
 
-@st.cache_resource(show_spinner=False)
-def _load_all():
-    # models
+try:
     model_bo = load_model(str(bo_model_path))
     model_bd = load_model(str(bd_model_path))
-    # metas
-    def _load_meta(p: Path):
-        if not p or not p.exists(): return {}
-        try:
-            return json.loads(p.read_text(encoding="utf-8"))
-        except Exception:
-            return {}
-    meta_bo = _load_meta(BO_META_PATH)
-    meta_bd = _load_meta(BD_META_PATH)
-
-    # Features: prefer model.feature_names_in_; else from bo meta; else bd meta
-    FEATURES = []
-    if hasattr(model_bo, "feature_names_in_"):
-        FEATURES = [str(x) for x in model_bo.feature_names_in_]
-    if not FEATURES and meta_bo.get("features"):
-        FEATURES = [str(x) for x in meta_bo["features"]]
-    if not FEATURES and meta_bd.get("features"):
-        FEATURES = [str(x) for x in meta_bd["features"]]
+except Exception as e:
+    st.error(f"Failed to load models: {e}"); st.stop()
 
-    # Targets from metas (your metas specify BO_Actual and BD_Actual)
-    TARGET_BO = str(meta_bo.get("target", "BO_Actual"))
-    TARGET_BD = str(meta_bd.get("target", "BD_Actual"))
+meta_bo = _load_meta(bo_meta_path)
+meta_bd = _load_meta(bd_meta_path)
 
-    return model_bo, model_bd, meta_bo, meta_bd, FEATURES, TARGET_BO, TARGET_BD
+# ---------------------------
+# Resolve FEATURES & targets
+# ---------------------------
+FEATURES = FEATURES_DEFAULT[:]          # fallback
+TARGET_BO = TARGET_BO_DEFAULT
+TARGET_BD = TARGET_BD_DEFAULT
 
-model_bo, model_bd, meta_bo, meta_bd, FEATURES, TARGET_BO, TARGET_BD = _load_all()
+# Prefer the model's trained feature names (golden source)
+try:
+    if hasattr(model_bo, "feature_names_in_"):
+        FEATURES = [str(x) for x in model_bo.feature_names_in_]
+except Exception:
+    pass
+
+# If still not set, fall back to BO meta, then BD meta, then defaults
+if not FEATURES and meta_bo.get("features"):
+    FEATURES = [str(x) for x in meta_bo["features"]]
+elif not FEATURES and meta_bd.get("features"):
+    FEATURES = [str(x) for x in meta_bd["features"]]
+
+# Targets (from metas if provided)
+if meta_bo.get("target"): TARGET_BO = str(meta_bo["target"])
+if meta_bd.get("target"): TARGET_BD = str(meta_bd["target"])
+
+# Units from metas; fallback to pcf (not ppg) + normalize spelling
+X_UNITS = meta_bo.get("units") or meta_bd.get("units") or "MW (pcf)"
+if isinstance(X_UNITS, str) and X_UNITS.strip().lower() in {"pcf", "mw (pcf)", "mw pcf"}:
+    X_UNITS = "MW (pcf)"
+
+# Canonical Depth name the model expects (if any)
+CANON_DEPTH = next((c for c in FEATURES if str(c).strip().lower().startswith("depth")), None)
+
+# Session constants for easy access elsewhere
+st.session_state["FEATURES"]      = FEATURES
+st.session_state["TARGET_BO"]     = TARGET_BO
+st.session_state["TARGET_BD"]     = TARGET_BD
+st.session_state["CANON_DEPTH"]   = CANON_DEPTH
+st.session_state["X_UNITS"]       = X_UNITS
+
+# Optional strict version banner
+if STRICT_VERSION_CHECK:
+    import numpy as _np, sklearn as _skl
+    msgs=[]
+    for nm, meta in [("BO", meta_bo), ("BD", meta_bd)]:
+        v = meta.get("versions", {})
+        if v.get("numpy") and v["numpy"] != _np.__version__:
+            msgs.append(f"[{nm}] NumPy {v['numpy']} expected, running {_np.__version__}")
+        if v.get("scikit_learn") and v["scikit_learn"] != _skl.__version__:
+            msgs.append(f"[{nm}] scikit-learn {v['scikit_learn']} expected, running {_skl.__version__}")
+    if msgs: st.warning("Environment mismatch: " + " | ".join(msgs))
 
-# Session constants
-st.session_state["FEATURES"]  = FEATURES
-st.session_state["TARGET_BO"] = TARGET_BO
-st.session_state["TARGET_BD"] = TARGET_BD
+# =========================
+# Session state
+# =========================
+st.session_state.setdefault("app_step", "intro")
+st.session_state.setdefault("results", {})
+st.session_state.setdefault("train_ranges", None)
+st.session_state.setdefault("dev_file_name","")
+st.session_state.setdefault("dev_file_bytes",b"")
+st.session_state.setdefault("dev_file_loaded",False)
+st.session_state.setdefault("dev_preview",False)
+st.session_state.setdefault("show_preview_modal", False)
 
 # =========================
-# App chrome
+# Sidebar branding
 # =========================
 st.sidebar.markdown(f"""
     <div class="centered-container">
+        <img src="{inline_logo('logo.png')}" class="brand-logo">
         <div style='font-weight:800;font-size:1.2rem;'>{APP_NAME}</div>
         <div style='color:#667085;'>{TAGLINE}</div>
     </div>
@@ -387,13 +767,17 @@ def sticky_header(title, message):
 # =========================
 # INTRO
 # =========================
-if "app_step" not in st.session_state:
-    st.session_state.app_step = "dev"
-
 if st.session_state.app_step == "intro":
     st.header("Welcome!")
-    st.markdown("This software estimates **Breakout** and **Breakdown** mud-weight limits from drilling data.")
-    if st.button("Start ▶", type="primary"):
+    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate **Breakout** and **Breakdown** mud weight limits from drilling data.")
+    st.subheader("How It Works")
+    st.markdown(
+        "1) **Upload your data** and preview.\n"
+        "2) Click **Run Model** to compute metrics and plots (Train/Test).\n"
+        "3) Proceed to **Validation** (with actual BO/BD) or **Prediction** (no actuals).\n"
+        "4) Use the **Combined** tab to see both limits on one track."
+    )
+    if st.button("Start Showcase", type="primary"):
         st.session_state.app_step = "dev"; st.rerun()
 
 # =========================
@@ -401,199 +785,272 @@ if st.session_state.app_step == "intro":
 # =========================
 if st.session_state.app_step == "dev":
     st.sidebar.header("Case Building")
-    up = st.sidebar.file_uploader("Upload Excel (Train/Test sheets)", type=["xlsx","xls"])
+    up = st.sidebar.file_uploader("Upload Your Data File", type=["xlsx","xls"])
+    if up is not None:
+        st.session_state.dev_file_bytes = up.getvalue()
+        st.session_state.dev_file_name = up.name
+        st.session_state.dev_file_loaded = True
+        st.session_state.dev_preview = False
+    if st.session_state.dev_file_loaded:
+        tmp = read_book_bytes(st.session_state.dev_file_bytes)
+        if tmp:
+            df0 = next(iter(tmp.values()))
+            st.sidebar.caption(f"**Data loaded:** {st.session_state.dev_file_name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
+
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded):
+        st.session_state.show_preview_modal = True
+        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()
 
-    sticky_header("Case Building", "Workbook must include **Train** and **Test** sheets. Accepts header aliases; Depth is optional and not used as input.")
-
-    if up is not None:
-        book = parse_excel(up.getvalue())
-        if not book:
-            st.error("Could not read Excel file.")
-            st.stop()
-
-        # Pick sheet names
-        def find_sheet(names):
-            low2orig = {k.lower(): k for k in book.keys()}
-            for nm in names:
-                if nm.lower() in low2orig: return low2orig[nm.lower()]
-            return None
-        sh_train = find_sheet(["Train","Training","training2","train","training"])
-        sh_test  = find_sheet(["Test","Testing","testing2","test","testing"])
+    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**.")
+    else:
+        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)
+        sh_train = find_sheet(book, ["Train","Training","training2","train","training"])
+        sh_test  = find_sheet(book, ["Test","Testing","testing2","test","testing"])
         if sh_train is None or sh_test is None:
-            st.error("Workbook must include Train/Training/training2 **and** Test/Testing/testing2 sheets.")
+            st.markdown('<div class="st-message-box st-error">Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets.</div>', unsafe_allow_html=True)
             st.stop()
 
-        # normalize headers with aliasing; targets from metas
-        def prepare(df_raw, stage):
-            df = _normalize_columns(df_raw, FEATURES, TARGET_BO, TARGET_BD)
-            # ensure required inputs exist
-            missing = [c for c in FEATURES if c not in df.columns]
-            if missing:
-                st.error(f"{stage}: Missing required input columns: {missing}\nFound: {list(df.columns)}\nExpected: {FEATURES}")
-                st.stop()
-            return df
-
-        tr = prepare(book[sh_train].copy(), "Training")
-        te = prepare(book[sh_test].copy(),  "Testing")
-
-        # Predict
-        Xtr = _make_X(tr, FEATURES)
-        Xte = _make_X(te, FEATURES)
+        # Normalize + ensure cols (robust depth handling)
+        tr = _prepare_table(book[sh_train].copy(), "Training", st.session_state["FEATURES"], st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], st.session_state["CANON_DEPTH"])
+        te = _prepare_table(book[sh_test].copy(),  "Testing",  st.session_state["FEATURES"], st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], st.session_state["CANON_DEPTH"])
+
+        # Predict with exact training feature order
+        Xtr = _make_X(tr, st.session_state["FEATURES"])  # only features
+        Xte = _make_X(te, st.session_state["FEATURES"])
         tr[PRED_BO] = model_bo.predict(Xtr)
         tr[PRED_BD] = model_bd.predict(Xtr)
         te[PRED_BO] = model_bo.predict(Xte)
         te[PRED_BD] = model_bd.predict(Xte)
 
-        # Metrics (requires BO_Actual / BD_Actual present)
-        def metrics_block(df, tgt, pred):
-            return {
-                "R":    pearson_r(df[tgt], df[pred]) if tgt in df else float("nan"),
-                "RMSE": rmse(df[tgt], df[pred]) if tgt in df else float("nan"),
-                "MAE":  mean_absolute_error(df[tgt], df[pred]) if tgt in df else float("nan"),
-            }
+        st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
+        st.session_state.results["m_train_bo"]={"R": pearson_r(tr[st.session_state["TARGET_BO"]], tr[PRED_BO]), "RMSE": rmse(tr[st.session_state["TARGET_BO"]], tr[PRED_BO]), "MAE": mean_absolute_error(tr[st.session_state["TARGET_BO"]], tr[PRED_BO])}
+        st.session_state.results["m_train_bd"]={"R": pearson_r(tr[st.session_state["TARGET_BD"]], tr[PRED_BD]), "RMSE": rmse(tr[st.session_state["TARGET_BD"]], tr[PRED_BD]), "MAE": mean_absolute_error(tr[st.session_state["TARGET_BD"]], tr[PRED_BD])}
+        st.session_state.results["m_test_bo"] ={"R": pearson_r(te[st.session_state["TARGET_BO"]], te[PRED_BO]), "RMSE": rmse(te[st.session_state["TARGET_BO"]], te[PRED_BO]), "MAE": mean_absolute_error(te[st.session_state["TARGET_BO"]], te[PRED_BO])}
+        st.session_state.results["m_test_bd"] ={"R": pearson_r(te[st.session_state["TARGET_BD"]], te[PRED_BD]), "RMSE": rmse(te[st.session_state["TARGET_BD"]], te[PRED_BD]), "MAE": mean_absolute_error(te[st.session_state["TARGET_BD"]], te[PRED_BD])}
 
-        m_train_bo = metrics_block(tr, TARGET_BO, PRED_BO)
-        m_train_bd = metrics_block(tr, TARGET_BD, PRED_BD)
-        m_test_bo  = metrics_block(te, TARGET_BO, PRED_BO)
-        m_test_bd  = metrics_block(te, TARGET_BD, PRED_BD)
+        tr_min = tr[st.session_state["FEATURES"]].min().to_dict(); tr_max = tr[st.session_state["FEATURES"]].max().to_dict()
+        st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in st.session_state["FEATURES"]}
+        st.markdown('<div class="st-message-box st-success">Case has been built and results are displayed below.</div>', unsafe_allow_html=True)
 
-        st.subheader("Training")
+    def _metrics_block(lbl, m):
         c1,c2,c3 = st.columns(3)
-        c1.metric("R (BO)", f"{m_train_bo['R']:.3f}")
-        c2.metric("RMSE (BO)", f"{m_train_bo['RMSE']:.2f}")
-        c3.metric("MAE (BO)", f"{m_train_bo['MAE']:.2f}")
-        c1,c2,c3 = st.columns(3)
-        c1.metric("R (BD)", f"{m_train_bd['R']:.3f}")
-        c2.metric("RMSE (BD)", f"{m_train_bd['RMSE']:.2f}")
-        c3.metric("MAE (BD)", f"{m_train_bd['MAE']:.2f}")
-
+        c1.metric(f"R ({lbl})",    f"{m['R']:.3f}")
+        c2.metric(f"RMSE ({lbl})", f"{m['RMSE']:.2f}")
+        c3.metric(f"MAE ({lbl})",  f"{m['MAE']:.2f}")
+
+    def _dev_block(df, mbo, mbd):
+        _metrics_block("BO", mbo); _metrics_block("BD", mbd)
+        st.markdown("""
+            <div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>
+                <strong>R:</strong> Pearson correlation • <strong>RMSE</strong> / <strong>MAE</strong> in MW units (pcf)
+            </div>
+        """, unsafe_allow_html=True)
         t1, t2, t3 = st.tabs(["Breakout", "Breakdown", "Combined"])
         with t1:
-            st.plotly_chart(track_plot_single(tr, PRED_BO, actual_col=TARGET_BO, title_suffix="Breakout"), use_container_width=False, config={"displayModeBar": False})
-            st.pyplot(cross_plot_static(tr[TARGET_BO], tr[PRED_BO], f"Actual {TARGET_BO}", f"Predicted {TARGET_BO}", COLORS["pred_bo"]))
+            st.plotly_chart(track_plot_single(df, PRED_BO, actual_col=st.session_state["TARGET_BO"], title_suffix="Breakout"), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.pyplot(cross_plot_static(df[st.session_state["TARGET_BO"]], df[PRED_BO], xlabel=f"Actual {st.session_state['TARGET_BO']}", ylabel=f"Predicted {st.session_state['TARGET_BO']}", color=COLORS["pred_bo"]), use_container_width=False)
         with t2:
-            st.plotly_chart(track_plot_single(tr, PRED_BD, actual_col=TARGET_BD, title_suffix="Breakdown"), use_container_width=False, config={"displayModeBar": False})
-            st.pyplot(cross_plot_static(tr[TARGET_BD], tr[PRED_BD], f"Actual {TARGET_BD}", f"Predicted {TARGET_BD}", COLORS["pred_bd"]))
+            st.plotly_chart(track_plot_single(df, PRED_BD, actual_col=st.session_state["TARGET_BD"], title_suffix="Breakdown"), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.pyplot(cross_plot_static(df[st.session_state["TARGET_BD"]], df[PRED_BD], xlabel=f"Actual {st.session_state['TARGET_BD']}", ylabel=f"Predicted {st.session_state['TARGET_BD']}", color=COLORS["pred_bd"]), use_container_width=False)
         with t3:
-            st.plotly_chart(track_plot_combined(tr, TARGET_BO, TARGET_BD), use_container_width=False, config={"displayModeBar": False})
-
-        st.subheader("Testing")
-        c1,c2,c3 = st.columns(3)
-        c1.metric("R (BO)", f"{m_test_bo['R']:.3f}")
-        c2.metric("RMSE (BO)", f"{m_test_bo['RMSE']:.2f}")
-        c3.metric("MAE (BO)", f"{m_test_bo['MAE']:.2f}")
-        c1,c2,c3 = st.columns(3)
-        c1.metric("R (BD)", f"{m_test_bd['R']:.3f}")
-        c2.metric("RMSE (BD)", f"{m_test_bd['RMSE']:.2f}")
-        c3.metric("MAE (BD)", f"{m_test_bd['MAE']:.2f}")
-
-        t1, t2, t3 = st.tabs(["Breakout ", "Breakdown ", "Combined "])
-        with t1:
-            st.plotly_chart(track_plot_single(te, PRED_BO, actual_col=TARGET_BO, title_suffix="Breakout"), use_container_width=False, config={"displayModeBar": False})
-            st.pyplot(cross_plot_static(te[TARGET_BO], te[PRED_BO], f"Actual {TARGET_BO}", f"Predicted {TARGET_BO}", COLORS["pred_bo"]))
-        with t2:
-            st.plotly_chart(track_plot_single(te, PRED_BD, actual_col=TARGET_BD, title_suffix="Breakdown"), use_container_width=False, config={"displayModeBar": False})
-            st.pyplot(cross_plot_static(te[TARGET_BD], te[PRED_BD], f"Actual {TARGET_BD}", f"Predicted {TARGET_BD}", COLORS["pred_bd"]))
-        with t3:
-            st.plotly_chart(track_plot_combined(te, TARGET_BO, TARGET_BD), use_container_width=False, config={"displayModeBar": False})
+            st.plotly_chart(track_plot_combined(df), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+
+    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_bo"], st.session_state.results["m_train_bd"])
+        if "Test" in st.session_state.results:
+            with tab2:
+                _dev_block(st.session_state.results["Test"], st.session_state.results["m_test_bo"], st.session_state.results["m_test_bd"])
+        render_export_button(phase_key="dev")
 
 # =========================
-# VALIDATION
+# VALIDATION (with actual BO/BD)
 # =========================
 if st.session_state.app_step == "validate":
     st.sidebar.header("Validate the Models")
-    up = st.sidebar.file_uploader("Upload Validation Excel (has actual BO/BD)", type=["xlsx","xls"])
+    up = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"])
+    if up is not None:
+        book = read_book_bytes(up.getvalue())
+        if book:
+            df0 = next(iter(book.values()))
+            st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
+    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()
 
-    sticky_header("Validation", "Upload a dataset with the same **5 feature** columns and **BO_Actual / BD_Actual** targets.")
-
-    if up is not None:
-        book = parse_excel(up.getvalue())
-        name = list(book.keys())[0]
-        df = _normalize_columns(book[name].copy(), FEATURES, TARGET_BO, TARGET_BD)
-
-        missing = [c for c in FEATURES if c not in df.columns]
-        if missing:
-            st.error(f"Missing input columns: {missing}\nFound: {list(df.columns)}\nExpected: {FEATURES}")
-            st.stop()
-
-        df[PRED_BO] = model_bo.predict(_make_X(df, FEATURES))
-        df[PRED_BD] = model_bd.predict(_make_X(df, FEATURES))
-
-        m_bo = {"R": pearson_r(df[TARGET_BO], df[PRED_BO]),
-                "RMSE": rmse(df[TARGET_BO], df[PRED_BO]),
-                "MAE": mean_absolute_error(df[TARGET_BO], df[PRED_BO])}
-        m_bd = {"R": pearson_r(df[TARGET_BD], df[PRED_BD]),
-                "RMSE": rmse(df[TARGET_BD], df[PRED_BD]),
-                "MAE": mean_absolute_error(df[TARGET_BD], df[PRED_BD])}
-
+    sticky_header("Validate the Models", "Upload a dataset with the same **features** and **BO/BD MW** to evaluate performance.")
+
+    if go_btn and up is not None:
+        book = read_book_bytes(up.getvalue())
+        name = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
+        df = _prepare_table(book[name].copy(), "Validation", st.session_state["FEATURES"], st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], st.session_state["CANON_DEPTH"])
+
+        df[PRED_BO] = model_bo.predict(_make_X(df, st.session_state["FEATURES"]))
+        df[PRED_BD] = model_bd.predict(_make_X(df, st.session_state["FEATURES"]))
+        st.session_state.results["Validate"]=df
+
+        ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
+        if ranges:
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in st.session_state["FEATURES"]}).any(axis=1)
+            oor_pct = float(any_viol.mean()*100.0)
+            if any_viol.any():
+                tbl = df.loc[any_viol, st.session_state["FEATURES"]].copy()
+                for c in st.session_state["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 st.session_state["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_bo"]={"R": pearson_r(df[st.session_state["TARGET_BO"]], df[PRED_BO]), "RMSE": rmse(df[st.session_state["TARGET_BO"]], df[PRED_BO]), "MAE": mean_absolute_error(df[st.session_state["TARGET_BO"]], df[PRED_BO])}
+        st.session_state.results["m_val_bd"]={"R": pearson_r(df[st.session_state["TARGET_BD"]], df[PRED_BD]), "RMSE": rmse(df[st.session_state["TARGET_BD"]], df[PRED_BD]), "MAE": mean_absolute_error(df[st.session_state["TARGET_BD"]], df[PRED_BD])}
+        st.session_state.results["sv_val"]={"n":len(df), "bo_min":float(df[PRED_BO].min()), "bo_max":float(df[PRED_BO].max()),
+                                            "bd_min":float(df[PRED_BD].min()), "bd_max":float(df[PRED_BD].max()), "oor":oor_pct}
+        st.session_state.results["oor_tbl"]=tbl
+
+    if "Validate" in st.session_state.results:
+        df = st.session_state.results["Validate"]
+        m_bo, m_bd = st.session_state.results["m_val_bo"], st.session_state.results["m_val_bd"]
         c1,c2,c3 = st.columns(3)
         c1.metric("R (BO)", f"{m_bo['R']:.3f}"); c2.metric("RMSE (BO)", f"{m_bo['RMSE']:.2f}"); c3.metric("MAE (BO)", f"{m_bo['MAE']:.2f}")
         c1,c2,c3 = st.columns(3)
         c1.metric("R (BD)", f"{m_bd['R']:.3f}"); c2.metric("RMSE (BD)", f"{m_bd['RMSE']:.2f}"); c3.metric("MAE (BD)", f"{m_bd['MAE']:.2f}")
+        st.markdown("<div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>R = Pearson correlation</div>", unsafe_allow_html=True)
 
         t1, t2, t3 = st.tabs(["Breakout", "Breakdown", "Combined"])
         with t1:
-            st.plotly_chart(track_plot_single(df, PRED_BO, actual_col=TARGET_BO, title_suffix="Breakout"),
-                            use_container_width=False, config={"displayModeBar": False})
-            st.pyplot(cross_plot_static(df[TARGET_BO], df[PRED_BO], f"Actual {TARGET_BO}", f"Predicted {TARGET_BO}", COLORS["pred_bo"]))
+            st.plotly_chart(track_plot_single(df, PRED_BO, actual_col=st.session_state["TARGET_BO"], title_suffix="Breakout"),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.pyplot(cross_plot_static(df[st.session_state["TARGET_BO"]], df[PRED_BO], f"Actual {st.session_state['TARGET_BO']}", f"Predicted {st.session_state['TARGET_BO']}", COLORS["pred_bo"]),
+                      use_container_width=False)
         with t2:
-            st.plotly_chart(track_plot_single(df, PRED_BD, actual_col=TARGET_BD, title_suffix="Breakdown"),
-                            use_container_width=False, config={"displayModeBar": False})
-            st.pyplot(cross_plot_static(df[TARGET_BD], df[PRED_BD], f"Actual {TARGET_BD}", f"Predicted {TARGET_BD}", COLORS["pred_bd"]))
+            st.plotly_chart(track_plot_single(df, PRED_BD, actual_col=st.session_state["TARGET_BD"], title_suffix="Breakdown"),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.pyplot(cross_plot_static(df[st.session_state["TARGET_BD"]], df[PRED_BD], f"Actual {st.session_state['TARGET_BD']}", f"Predicted {st.session_state['TARGET_BD']}", COLORS["pred_bd"]),
+                      use_container_width=False)
         with t3:
-            st.plotly_chart(track_plot_combined(df, TARGET_BO, TARGET_BD), use_container_width=False, config={"displayModeBar": False})
+            st.plotly_chart(track_plot_combined(df), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+
+        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 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"])
 
 # =========================
 # PREDICTION (no actuals)
 # =========================
 if st.session_state.app_step == "predict":
     st.sidebar.header("Prediction (No Actual BO/BD)")
-    up = st.sidebar.file_uploader("Upload Prediction Excel (features only)", type=["xlsx","xls"])
+    up = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"])
+    if up is not None:
+        book = read_book_bytes(up.getvalue())
+        if book:
+            df0 = next(iter(book.values()))
+            st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
+    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()
 
-    sticky_header("Prediction", "Upload a dataset with **only the 5 feature columns**.")
+    sticky_header("Prediction", "Upload a dataset with **feature columns only** (no BO/BD actuals).")
 
-    if up is not None:
-        book = parse_excel(up.getvalue()); name = list(book.keys())[0]
-        df = _normalize_columns(book[name].copy(), FEATURES, TARGET_BO, TARGET_BD)
-        missing = [c for c in FEATURES if c not in df.columns]
-        if missing:
-            st.error(f"Missing input columns: {missing}\nFound: {list(df.columns)}\nExpected: {FEATURES}")
-            st.stop()
+    if go_btn and up is not None:
+        book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
+        df = _prepare_table(book[name].copy(), "Prediction", st.session_state["FEATURES"], st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], st.session_state["CANON_DEPTH"])
+
+        df[PRED_BO] = model_bo.predict(_make_X(df, st.session_state["FEATURES"]))
+        df[PRED_BD] = model_bd.predict(_make_X(df, st.session_state["FEATURES"]))
+        st.session_state.results["PredictOnly"]=df
 
-        df[PRED_BO] = model_bo.predict(_make_X(df, FEATURES))
-        df[PRED_BD] = model_bd.predict(_make_X(df, FEATURES))
+        ranges = st.session_state.train_ranges; oor_pct = 0.0
+        if ranges:
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in st.session_state["FEATURES"]}).any(axis=1)
+            oor_pct = float(any_viol.mean()*100.0)
+        st.session_state.results["sv_pred"]={
+            "n":len(df),
+            "bo_min":float(df[PRED_BO].min()), "bo_max":float(df[PRED_BO].max()),
+            "bd_min":float(df[PRED_BD].min()), "bd_max":float(df[PRED_BD].max()),
+            "bo_mean":float(df[PRED_BO].mean()), "bo_std":float(df[PRED_BO].std(ddof=0)),
+            "bd_mean":float(df[PRED_BD].mean()), "bd_std":float(df[PRED_BD].std(ddof=0)),
+            "oor":oor_pct
+        }
+
+    if "PredictOnly" in st.session_state.results:
+        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:
-            sv = {
-                "n":len(df),
-                "bo_min":float(df[PRED_BO].min()), "bo_max":float(df[PRED_BO].max()),
-                "bd_min":float(df[PRED_BD].min()), "bd_max":float(df[PRED_BD].max()),
-                "bo_mean":float(df[PRED_BO].mean()), "bo_std":float(df[PRED_BO].std(ddof=0)),
-                "bd_mean":float(df[PRED_BD].mean()), "bd_std":float(df[PRED_BD].std(ddof=0)),
-            }
             table = pd.DataFrame({
-                "Metric": ["# points","BO min","BO max","BO mean","BO std","BD min","BD max","BD mean","BD std"],
+                "Metric": ["# points","BO min","BO max","BO mean","BO std","BD min","BD max","BD mean","BD std","OOR %"],
                 "Value": [sv["n"], round(sv["bo_min"],2), round(sv["bo_max"],2), round(sv["bo_mean"],2), round(sv["bo_std"],2),
-                          round(sv["bd_min"],2), round(sv["bd_max"],2), round(sv["bd_mean"],2), round(sv["bd_std"],2)]
+                          round(sv["bd_min"],2), round(sv["bd_max"],2), round(sv["bd_mean"],2), round(sv["bd_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)
+            st.caption("**★ OOR** = % of rows whose input features fall outside the training min–max range.")
         with col_right:
             t1, t2 = st.tabs(["Breakout", "Breakdown"])
             with t1:
                 st.plotly_chart(track_plot_single(df, PRED_BO, actual_col=None, title_suffix="Breakout"),
-                                use_container_width=False, config={"displayModeBar": False})
+                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
             with t2:
                 st.plotly_chart(track_plot_single(df, PRED_BD, actual_col=None, title_suffix="Breakdown"),
-                                use_container_width=False, config={"displayModeBar": False})
-            st.plotly_chart(track_plot_combined(df, TARGET_BO, TARGET_BD), use_container_width=False, config={"displayModeBar": False})
+                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.plotly_chart(track_plot_combined(df), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+
+        render_export_button(phase_key="predict")
+
+# =========================
+# Preview modal
+# =========================
+if st.session_state.show_preview_modal:
+    book_to_preview = {}
+    if st.session_state.app_step == "dev":
+        book_to_preview = read_book_bytes(st.session_state.dev_file_bytes)
+    elif st.session_state.app_step in ["validate", "predict"] and 'up' in locals() and up is not None:
+        book_to_preview = read_book_bytes(up.getvalue())
+
+    with st.expander("Preview data", expanded=True):
+        if not book_to_preview:
+            st.markdown('<div class="st-message-box">No data loaded yet.</div>', unsafe_allow_html=True)
+        else:
+            names = list(book_to_preview.keys())
+            tabs = st.tabs(names)
+            for t, name in zip(tabs, names):
+                with t:
+                    df = _prepare_table(book_to_preview[name], "Preview", st.session_state["FEATURES"], st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], st.session_state["CANON_DEPTH"])
+                    t1, t2 = st.tabs(["Tracks", "Summary"])
+                    with t1:
+                        st.pyplot(preview_tracks(df, st.session_state["FEATURES"]), use_container_width=True)
+                    with t2:
+                        feat_present = [c for c in st.session_state["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)
+
+    st.session_state.show_preview_modal = False
 
 # =========================
 # Footer
@@ -602,6 +1059,7 @@ st.markdown("""
 <br><br><br>
 <hr>
 <div style='text-align:center;color:#6b7280;font-size:1.0em;'>
-    © 2025 Smart Thinking AI-Solutions Team. All rights reserved.
+    © 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)