Update app.py

app.py

@@ -4,82 +4,75 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 import joblib
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
 
-# --- Plotly (interactive) ---
+# NEW: Plotly for interactive charts (keeps styling the same)
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-
-from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
 
-# =========================================================
-# Defaults (overridden by models/meta.json or model.feature_names_in_)
-# =========================================================
+# =========================
+# Defaults
+# =========================
 FEATURES = ["Q, gpm", "SPP(psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
 TARGET = "UCS"
 MODELS_DIR = Path("models")
 DEFAULT_MODEL = MODELS_DIR / "ucs_rf.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 
-# =========================================================
-# Page / Theme + CSS
-# =========================================================
-st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
+COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
+# =========================
+# Page / Theme
+# =========================
+st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
+st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
 st.markdown(
     """
     <style>
-    /* App + sidebar background */
     .stApp { background: #FFFFFF; }
     section[data-testid="stSidebar"] { background: #F6F9FC; }
-
-    /* Tighten top spacing */
-    [data-testid="stBlock"]{ margin-top: 0 !important; }
-
-    /* Hero row */
-    .st-hero { display:flex; align-items:center; gap:16px; padding-top: 6px; }
-    .st-hero .brand { width:90px; height:90px; object-fit:contain; }
+    .block-container { padding-top: .5rem; padding-bottom: .5rem; }
+    .stButton>button{ background:#007bff; color:#fff; font-weight:bold; border-radius:8px; border:none; padding:10px 24px; }
+    .stButton>button:hover{ background:#0056b3; }
+    .st-hero { display:flex; align-items:center; gap:16px; padding-top: 4px; }
+    .st-hero .brand { width:110px; height:110px; object-fit:contain; }
     .st-hero h1 { margin:0; line-height:1.05; }
     .st-hero .tagline { margin:2px 0 0 2px; color:#6b7280; font-size:1.05rem; font-style:italic; }
-
-    /* Sidebar button palette (order-based within the Sidebar section)
-       1) Preview (orange)  2) Run (blue)  3) Proceed (green)
-       We scope to the sidebar and to stButton blocks only. */
-    section[data-testid="stSidebar"] div.stButton > button {
-        font-weight:700; border-radius:10px; border:none; padding:10px 20px;
-    }
-    section[data-testid="stSidebar"] div.stButton:nth-of-type(1) > button { /* Preview */
-        background:#f59e0b; color:#fff;
-    }
-    section[data-testid="stSidebar"] div.stButton:nth-of-type(2) > button { /* Run (blue) */
-        background:#2563eb; color:#fff;
-    }
-    section[data-testid="stSidebar"] div.stButton:nth-of-type(3) > button { /* Proceed (green) */
-        background:#10b981; color:#fff;
-    }
-    section[data-testid="stSidebar"] div.stButton:nth-of-type(3) > button:disabled {
-        background:#a7f3d0 !important; color:#064e3b !important; opacity:.7 !important;
-    }
-
-    /* Modal tabs spacing */
-    .stTabs [data-baseweb="tab-list"] { gap: 6px; }
+    [data-testid="stBlock"]{ margin-top:0 !important; }
     </style>
     """,
     unsafe_allow_html=True
 )
 
-# =========================================================
+# =========================
 # Helpers
-# =========================================================
-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 ""
+# =========================
+try:
+    dialog = st.dialog
+except AttributeError:
+    # Fallback (expander) if st.dialog is unavailable
+    def dialog(title):
+        def deco(fn):
+            def wrapper(*args, **kwargs):
+                with st.expander(title, expanded=True):
+                    return fn(*args, **kwargs)
+            return wrapper
+        return deco
+
+def _get_model_url():
+    return (os.environ.get("MODEL_URL", "") or "").strip()
 
 def rmse(y_true, y_pred): return float(np.sqrt(mean_squared_error(y_true, y_pred)))
 
+def ensure_cols(df, cols):
+    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
+
 @st.cache_resource(show_spinner=False)
 def load_model(model_path: str):
     return joblib.load(model_path)
@@ -90,187 +83,348 @@ def parse_excel(data_bytes: bytes):
     xl = pd.ExcelFile(bio)
     return {sh: xl.parse(sh) for sh in xl.sheet_names}
 
-def ensure_cols(df, cols):
-    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 read_book_bytes(data_bytes: bytes):
+    if not data_bytes: return {}
+    try: return parse_excel(data_bytes)
+    except Exception as e:
+        st.error(f"Failed to read Excel: {e}"); return {}
 
-def infer_features_from_model(m):
-    try:
-        if hasattr(m, "feature_names_in_") and len(getattr(m, "feature_names_in_")):
-            return [str(x) for x in m.feature_names_in_]
-    except Exception: pass
-    try:
-        if hasattr(m, "steps") and len(m.steps):
-            last = m.steps[-1][1]
-            if hasattr(last, "feature_names_in_") and len(last.feature_names_in_):
-                return [str(x) for x in last.feature_names_in_]
-    except Exception: pass
+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
 
-def export_workbook(sheets_dict, summary_df=None):
-    try: import openpyxl  # ensure engine is available
-    except Exception:
-        raise RuntimeError("Export requires openpyxl. Please add it to requirements.txt.")
-    buf = io.BytesIO()
-    with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-        for name, frame in sheets_dict.items():
-            frame.to_excel(xw, sheet_name=name[:31], index=False)
-        if summary_df is not None:
-            summary_df.to_excel(xw, sheet_name="Summary", index=False)
-    return buf.getvalue()
-
-# -------------------- Plotly styling blocks --------------------
-AXES_STYLE = dict(
-    showline=True, linewidth=1.4, linecolor="#444",
-    mirror=True, ticks="outside", ticklen=4, tickwidth=1,
-    showgrid=True, gridcolor="rgba(0,0,0,0.08)"
-)
-FONT = dict(color="#111", size=13)
+# ---------- ORIGINAL Matplotlib plotters (kept for reference) ----------
+def cross_plot(actual, pred, title, size=(3.9, 3.9)):
+    fig, ax = plt.subplots(figsize=size, dpi=100)
+    ax.scatter(actual, pred, s=14, alpha=0.85, color=COLORS["pred"])
+    lo = float(np.nanmin([actual.min(), pred.min()]))
+    hi = float(np.nanmax([actual.max(), pred.max()]))
+    pad = 0.03 * (hi - lo if hi > lo else 1.0)
+    ax.plot([lo - pad, hi + pad], [lo - pad, hi + pad], '--', lw=1.2, color=COLORS["ref"])
+    ax.set_xlim(lo - pad, hi + pad); ax.set_ylim(lo - pad, hi + pad)
+    ax.set_aspect('equal', 'box')
+    ax.set_xlabel("Actual UCS"); ax.set_ylabel("Predicted UCS"); ax.set_title(title)
+    ax.grid(True, ls=":", alpha=0.4)
+    return fig
 
-def style_layout(fig, width=None, height=None, margins=(12,18,36,12)):
-    t, r, b, l = margins
-    fig.update_layout(
-        margin=dict(t=t, r=r, b=b, l=l),
-        paper_bgcolor="white",
-        plot_bgcolor="white",
-        font=FONT,
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
-    )
-    if width: fig.update_layout(width=width)
-    if height: fig.update_layout(height=height)
-    # Apply to all axes
-    fig.update_xaxes(**AXES_STYLE, title_font=dict(size=14, color="#111"))
-    fig.update_yaxes(**AXES_STYLE, title_font=dict(size=14, color="#111"))
+def depth_or_index_track(df, title=None, include_actual=True):
+    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
+    fig_w = 3.1
+    fig_h = 7.6 if depth_col is not None else 7.2
+    fig, ax = plt.subplots(figsize=(fig_w, fig_h), dpi=100)
+    if depth_col is not None:
+        ax.plot(df["UCS_Pred"], df[depth_col], '-', lw=1.8, color=COLORS["pred"], label="UCS_Pred")
+        if include_actual and TARGET in df.columns:
+            ax.plot(df[TARGET], df[depth_col], ':', lw=2.0, color=COLORS["actual"], alpha=0.95, label="UCS (actual)")
+        ax.set_ylabel(depth_col); ax.set_xlabel("UCS")
+        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
+    else:
+        idx = np.arange(1, len(df) + 1)
+        ax.plot(df["UCS_Pred"], idx, '-', lw=1.8, color=COLORS["pred"], label="UCS_Pred")
+        if include_actual and TARGET in df.columns:
+            ax.plot(df[TARGET], idx, ':', lw=2.0, color=COLORS["actual"], alpha=0.95, label="UCS (actual)")
+        ax.set_ylabel("Point Index"); ax.set_xlabel("UCS")
+        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
+    ax.grid(True, linestyle=":", alpha=0.4)
+    if title: ax.set_title(title, pad=8)
+    ax.legend(loc="best")
     return fig
 
-def make_cross_plotly(A, P, height=440, width=640):
-    a = pd.Series(A).astype(float)
-    p = pd.Series(P).astype(float)
+# ---------- NEW: Plotly equivalents (interactive, same specs) ----------
+def cross_plot_interactive(actual, pred, title, size=(3.9, 3.9)):
+    """Interactive cross-plot with the same look: blue points, dashed 1:1, equal axes, grid, title."""
+    a = pd.Series(actual).astype(float)
+    p = pd.Series(pred).astype(float)
     lo = float(np.nanmin([a.min(), p.min()]))
     hi = float(np.nanmax([a.max(), p.max()]))
+    pad = 0.03 * (hi - lo if hi > lo else 1.0)
+    x0, x1 = lo - pad, hi + pad
 
     fig = go.Figure()
+
+    # points
     fig.add_trace(go.Scatter(
-        x=a, y=p, mode="markers", name="Points", marker=dict(size=6)
+        x=a, y=p,
+        mode="markers",
+        marker=dict(size=6, color=COLORS["pred"]),
+        hovertemplate="Actual: %{x:.2f}<br>Pred: %{y:.2f}<extra></extra>",
+        name="Points",
+        showlegend=False
     ))
+
+    # 1:1
     fig.add_trace(go.Scatter(
-        x=[lo, hi], y=[lo, hi], mode="lines", name="1:1",
-        line=dict(color="#666", width=2, dash="dash")
+        x=[x0, x1], y=[x0, x1],
+        mode="lines",
+        line=dict(color=COLORS["ref"], width=1.2, dash="dash"),
+        hoverinfo="skip",
+        name="1:1",
+        showlegend=False
     ))
-    fig.update_xaxes(range=[lo, hi], title="Actual UCS")
-    fig.update_yaxes(range=[lo, hi], title="Predicted UCS", scaleanchor="x", scaleratio=1)
-    style_layout(fig, width=width, height=height, margins=(8,10,36,50))
+
+    fig.update_layout(
+        title=title,
+        paper_bgcolor="#ffffff",
+        plot_bgcolor="#ffffff",
+        margin=dict(l=50, r=10, t=36, b=36),
+        hovermode="closest",
+        font=dict(size=13)
+    )
+    fig.update_xaxes(
+        title_text="<b>Actual UCS</b>",
+        range=[x0, x1],
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
+        automargin=True
+    )
+    fig.update_yaxes(
+        title_text="<b>Predicted UCS</b>",
+        range=[x0, x1],
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
+        scaleanchor="x", scaleratio=1,
+        automargin=True
+    )
+
+    # match your size ~ inches * 100 dpi
+    w = int(size[0] * 100)
+    h = int(size[1] * 100)
+    fig.update_layout(width=w, height=h)
     return fig
 
-def make_depth_track_plotly(df, include_actual=True, height=640, width=360):
-    idx = np.arange(1, len(df) + 1)
+def depth_or_index_track_interactive(df, title=None, include_actual=True):
+    """Interactive narrow/tall UCS track: blue solid pred, yellow dotted actual, top x-axis, inverted y."""
+    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
+    if depth_col is not None:
+        y = df[depth_col]
+        y_label = depth_col
+    else:
+        y = np.arange(1, len(df) + 1)
+        y_label = "Point Index"
+
     fig = go.Figure()
+
     # Predicted (solid blue)
     fig.add_trace(go.Scatter(
-        x=df["UCS_Pred"], y=idx, mode="lines", name="UCS_Pred",
-        line=dict(color="#1f77b4", width=2)
+        x=df["UCS_Pred"], y=y,
+        mode="lines",
+        line=dict(color=COLORS["pred"], width=1.8),
+        name="UCS_Pred",
+        hovertemplate="UCS_Pred: %{x:.2f}<br>"+y_label+": %{y}<extra></extra>"
     ))
+
     # Actual (dotted yellow)
     if include_actual and TARGET in df.columns:
         fig.add_trace(go.Scatter(
-            x=df[TARGET], y=idx, mode="lines", name="UCS (actual)",
-            line=dict(color="#f2b01e", width=2, dash="dot")
+            x=df[TARGET], y=y,
+            mode="lines",
+            line=dict(color=COLORS["actual"], width=2.0, dash="dot"),
+            name="UCS (actual)",
+            hovertemplate="UCS (actual): %{x:.2f}<br>"+y_label+": %{y}<extra></extra>"
         ))
-    fig.update_yaxes(autorange="reversed", title="Point Index")
-    fig.update_xaxes(title="UCS")
-    style_layout(fig, width=width, height=height, margins=(8,12,36,60))
+
+    fig.update_layout(
+        title=title if title else None,
+        paper_bgcolor="#ffffff",
+        plot_bgcolor="#ffffff",
+        margin=dict(l=60, r=10, t=36, b=36),
+        hovermode="closest",
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, x=0),
+        font=dict(size=13),
+        # keep it tall & narrow like your Matplotlib version (~3.1in x 7.6in @100dpi)
+        width=int(3.1 * 100),
+        height=int((7.6 if depth_col is not None else 7.2) * 100),
+    )
+    fig.update_xaxes(
+        title_text="<b>UCS</b>", side="top",
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
+        automargin=True
+    )
+    fig.update_yaxes(
+        title_text=f"<b>{y_label}</b>",
+        autorange="reversed",
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
+        automargin=True
+    )
     return fig
 
-def make_index_tracks_plotly(df, feature_cols, height=640, width=980):
-    n = len(feature_cols)
-    fig = make_subplots(rows=1, cols=n, shared_yaxes=True, horizontal_spacing=0.05)
-    idx = np.arange(1, len(df) + 1)
+def export_workbook(sheets_dict, summary_df=None):
+    try: import openpyxl  # noqa
+    except Exception: raise RuntimeError("Export requires openpyxl. Please add it to requirements or install it.")
+    buf = io.BytesIO()
+    with pd.ExcelWriter(buf, engine="openpyxl") as xw:
+        for name, frame in sheets_dict.items():
+            frame.to_excel(xw, sheet_name=name[:31], index=False)
+        if summary_df is not None: summary_df.to_excel(xw, sheet_name="Summary", index=False)
+    return buf.getvalue()
 
-    for i, col in enumerate(feature_cols, start=1):
-        fig.add_trace(
-            go.Scatter(x=df[col], y=idx, mode="lines", line=dict(color="#444", width=1.2), name=col, showlegend=False),
-            row=1, col=i
-        )
-        fig.update_xaxes(title=col, row=1, col=i)
-    fig.update_yaxes(autorange="reversed", title="Point Index", row=1, col=1)
-    style_layout(fig, width=width, height=height, margins=(6,8,36,60))
-    return fig
+def toast(msg):
+    try: st.toast(msg)
+    except Exception: st.info(msg)
 
-# =========================================================
-# Model availability (cloud-safe)
-# =========================================================
-def _get_model_url():
+def infer_features_from_model(m):
     try:
-        return (st.secrets.get("MODEL_URL", "") or os.environ.get("MODEL_URL", "") or "").strip()
+        if hasattr(m, "feature_names_in_") and len(getattr(m, "feature_names_in_")):
+            return [str(x) for x in m.feature_names_in_]
+    except Exception: pass
+    try:
+        if hasattr(m, "steps") and len(m.steps):
+            last = m.steps[-1][1]
+            if hasattr(last, "feature_names_in_") and len(last.feature_names_in_):
+                return [str(x) for x in last.feature_names_in_]
+    except Exception: pass
+    return None
+
+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 (os.environ.get("MODEL_URL", "") or "").strip()
+        return ""
+
+# ---------- Preview modal helpers (unchanged; still Matplotlib) ----------
+def make_index_tracks(df: pd.DataFrame, cols: list[str]):
+    cols = [c for c in cols if c in df.columns]
+    n = len(cols)
+    if n == 0:
+        fig, ax = plt.subplots(figsize=(4, 2))
+        ax.text(0.5, 0.5, "No selected columns in sheet", ha="center", va="center")
+        ax.axis("off"); return fig
+    width_per = 2.2
+    fig_h = 7.0
+    fig, axes = plt.subplots(1, n, figsize=(width_per * n, fig_h), sharey=True, dpi=100)
+    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.set_xlabel(col)
+        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
+        ax.grid(True, linestyle=":", alpha=0.3)
+    axes[0].set_ylabel("Point Index")
+    return fig
 
-def ensure_model_present() -> Path | None:
-    # local candidates
+def stats_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({"Feature": [], "Min": [], "Max": [], "Mean": [], "Std": []})
+    out = df[cols].agg(['min', 'max', 'mean', 'std']).T
+    out = out.rename(columns={"min": "Min", "max": "Max", "mean": "Mean", "std": "Std"})
+    return out.reset_index().rename(columns={"index": "Feature"})
+
+@dialog("Preview data")
+def preview_modal_dev(book: dict[str, pd.DataFrame], feature_cols: list[str]):
+    if not book:
+        st.info("No data loaded yet."); return
+    sh_train = find_sheet(book, ["Train","Training","training2","train","training"])
+    sh_test  = find_sheet(book, ["Test","Testing","testing2","test","testing"])
+    tabs, data = [], []
+    if sh_train: tabs.append("Train"); data.append(book[sh_train])
+    if sh_test:  tabs.append("Test");  data.append(book[sh_test])
+    if not tabs:
+        first_name = list(book.keys())[0]
+        tabs = [first_name]; data = [book[first_name]]
+    st.write("Use the tabs to switch between Train/Test views (if available).")
+    t_objs = st.tabs(tabs)
+    for t, df in zip(t_objs, data):
+        with t:
+            t1, t2 = st.tabs(["Tracks", "Summary"])
+            with t1: st.pyplot(make_index_tracks(df, feature_cols), use_container_width=True)
+            with t2: st.dataframe(stats_table(df, feature_cols), use_container_width=True)
+
+@dialog("Preview data")
+def preview_modal_val(book: dict[str, pd.DataFrame], feature_cols: list[str]):
+    if not book:
+        st.info("No data loaded yet."); return
+    vname = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
+    df = book[vname]
+    t1, t2 = st.tabs(["Tracks", "Summary"])
+    with t1: st.pyplot(make_index_tracks(df, feature_cols), use_container_width=True)
+    with t2: st.dataframe(stats_table(df, feature_cols), use_container_width=True)
+
+# =========================
+# Model presence
+# =========================
+MODEL_URL = _get_model_url()
+
+def ensure_model_present() -> Path:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
-        if p.exists():
+        if p.exists() and p.stat().st_size > 0:
             return p
-    # cloud download
-    MODEL_URL = _get_model_url()
-    if MODEL_URL:
-        try:
-            import requests
-            DEFAULT_MODEL.parent.mkdir(parents=True, exist_ok=True)
-            with requests.get(MODEL_URL, stream=True) as r:
+    if not MODEL_URL:
+        return None
+    try:
+        import requests
+        DEFAULT_MODEL.parent.mkdir(parents=True, exist_ok=True)
+        with st.status("Downloading model…", expanded=False):
+            with requests.get(MODEL_URL, stream=True, timeout=30) as r:
                 r.raise_for_status()
                 with open(DEFAULT_MODEL, "wb") as f:
                     for chunk in r.iter_content(chunk_size=1<<20):
-                        f.write(chunk)
-            return DEFAULT_MODEL
-        except Exception as e:
-            st.error(f"Failed to download model from MODEL_URL: {e}")
-    return None
+                        if chunk: f.write(chunk)
+        return DEFAULT_MODEL
+    except Exception as e:
+        st.error(f"Failed to download model from MODEL_URL: {e}")
+        return None
 
 model_path = ensure_model_present()
 if not model_path:
-    st.error("Model not found. Upload models/ucs_rf.joblib (or set MODEL_URL).")
+    st.error("Model not found. Upload models/ucs_rf.joblib (or set MODEL_URL in Settings → Variables).")
     st.stop()
 
-# Load model
 try:
     model = load_model(str(model_path))
 except Exception as e:
     st.error(f"Failed to load model: {model_path}\n{e}")
     st.stop()
 
-# Meta overrides
+# Meta overrides / inference
 meta_path = MODELS_DIR / "meta.json"
 if meta_path.exists():
     try:
         meta = json.loads(meta_path.read_text(encoding="utf-8"))
-        FEATURES = meta.get("features", FEATURES)
-        TARGET = meta.get("target", TARGET)
-    except Exception:
-        pass
+        FEATURES = meta.get("features", FEATURES); TARGET = meta.get("target", TARGET)
+    except Exception: pass
 else:
     infer = infer_features_from_model(model)
     if infer: FEATURES = infer
 
-# =========================================================
-# Session state defaults
-# =========================================================
-ss = st.session_state
-ss.setdefault("app_step", "intro")   # ← we start on Intro
-ss.setdefault("dev_bytes", None)
-ss.setdefault("dev_book", None)
-ss.setdefault("dev_previewed", False)
-ss.setdefault("dev_ran", False)
-ss.setdefault("results", {})
-ss.setdefault("train_ranges", None)
-ss.setdefault("val_bytes", None)
-ss.setdefault("val_book", None)
-
-# =========================================================
-# HERO (logo + title)
-# =========================================================
+# =========================
+# Session state
+# =========================
+if "app_step" not in st.session_state: st.session_state.app_step = "intro"
+if "results" not in st.session_state: st.session_state.results = {}
+if "train_ranges" not in st.session_state: st.session_state.train_ranges = None
+
+# Dev page state (persist file)
+for k, v in {
+    "dev_ready": False,
+    "dev_file_loaded": False,
+    "dev_previewed": False,
+    "dev_file_signature": None,
+    "dev_preview_request": False,
+    "dev_file_bytes": b"",
+    "dev_file_name": "",
+    "dev_file_rows": 0,
+    "dev_file_cols": 0,
+}.items():
+    if k not in st.session_state: st.session_state[k] = v
+
+# =========================
+# Hero header
+# =========================
+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 ""
+
 st.markdown(
     f"""
     <div class="st-hero">
@@ -284,277 +438,317 @@ st.markdown(
     unsafe_allow_html=True,
 )
 
-# =========================================================
+# =========================
 # INTRO PAGE
-# =========================================================
-if ss.app_step == "intro":
+# =========================
+if st.session_state.app_step == "intro":
     st.header("Welcome!")
     st.markdown(
-        "1. **Upload your data to build the case** and preview the performance of our model.  \n"
-        "2. Click **Run Model** to compute metrics, cross-plots, and the index track.  \n"
-        "3. Click **Proceed to Prediction** to validate on a new dataset."
+        "This software is developed by *Smart Thinking AI-Solutions Team* to estimate UCS from drilling data."
     )
-    if st.button("Start", type="primary"):
-        ss.app_step = "dev"
-        st.rerun()
-
-# =========================================================
-# Helper banner (stays at top of Development page)
-# =========================================================
-def render_dev_helper():
-    st.subheader("Model Development")
-    if not ss.dev_bytes:
-        st.info("Upload your data to build the case and preview the performance of our model.")
-    elif ss.dev_bytes and not ss.dev_previewed and not ss.dev_ran:
-        st.info("File loaded — click **Preview data**.")
-    elif ss.dev_previewed and not ss.dev_ran:
-        st.info("Previewed ✓ — now click **Run Model** to build the case.")
-    elif ss.dev_ran:
-        st.success("Case built ✓ — results are displayed below. You can now **Proceed to Prediction**.")
-
-# =========================================================
-# PREVIEW MODAL
-# =========================================================
-def preview_modal_dev(book, feature_cols):
-    sh_train = None
-    sh_test  = None
-    # try common names
-    low2orig = {k.lower(): k for k in book.keys()}
-    for nm in ["train","training","training2"]:
-        if nm in low2orig: sh_train = low2orig[nm]; break
-    for nm in ["test","testing","testing2"]:
-        if nm in low2orig: sh_test  = low2orig[nm]; break
-
-    tabs = st.tabs(["Tracks", "Summary"])
-    with tabs[0]:
-        # prefer Train if available; else first sheet
-        pick = sh_train or list(book.keys())[0]
-        df = book[pick]
-        # only numeric columns needed for plotting
-        ok_cols = [c for c in feature_cols if c in df.columns]
-        if not ok_cols:
-            st.warning("No matching feature columns found for plotting.")
-        else:
-            fig = make_index_tracks_plotly(df, ok_cols, height=640, width=1000)
-            st.plotly_chart(fig, use_container_width=True, theme=None)
-    with tabs[1]:
-        pick = sh_train or list(book.keys())[0]
-        df = book[pick]
-        st.dataframe(
-            df.describe().T.rename(columns={
-                "mean":"Mean","std":"Std","min":"Min","max":"Max"
-            })[["Min","Max","Mean","Std"]].round(4),
-            use_container_width=True
+    st.subheader("Required Input Columns")
+    st.markdown(
+        "- Q, gpm — Flow rate (gallons per minute)  \n"
+        "- SPP(psi) — Stand pipe pressure  \n"
+        "- T (kft.lbf) — Torque (thousand foot-pounds)  \n"
+        "- WOB (klbf) — Weight on bit  \n"
+        "- ROP (ft/h) — Rate of penetration"
+    )
+    st.subheader("How It Works")
+    st.markdown(
+        "1. **Upload your data to build the case and preview the performance of our model.**  \n"
+        "2. Click **Run Model** to compute metrics and plots.  \n"
+        "3. Click **Proceed to Prediction** to validate on a new dataset.  \n"
+        "4. Export results to Excel at any time."
+    )
+    if st.button("Start Showcase", type="primary", key="start_showcase"):
+        st.session_state.app_step = "dev"; st.rerun()
+
+# =========================
+# MODEL DEVELOPMENT
+# =========================
+if st.session_state.app_step == "dev":
+    st.sidebar.header("Model Development Data")
+    dev_label = "Upload Data (Excel)" if not st.session_state.dev_file_name else "Replace data (Excel)"
+    train_test_file = st.sidebar.file_uploader(dev_label, type=["xlsx","xls"], key="dev_upload")
+
+    # Detect new/changed file and PERSIST BYTES
+    if train_test_file is not None:
+        try:
+            file_bytes = train_test_file.getvalue()
+            size = len(file_bytes)
+        except Exception:
+            file_bytes = b""
+            size = 0
+        sig = (train_test_file.name, size)
+        if sig != st.session_state.dev_file_signature and size > 0:
+            st.session_state.dev_file_signature = sig
+            st.session_state.dev_file_name = train_test_file.name
+            st.session_state.dev_file_bytes = file_bytes
+            # Inspect first sheet for rows/cols
+            _book_tmp = read_book_bytes(file_bytes)
+            if _book_tmp:
+                first_df = next(iter(_book_tmp.values()))
+                st.session_state.dev_file_rows = int(first_df.shape[0])
+                st.session_state.dev_file_cols = int(first_df.shape[1])
+                st.session_state.dev_file_loaded = True
+                st.session_state.dev_previewed = False
+                st.session_state.dev_ready = False
+
+    # Sidebar caption (from persisted info)
+    if st.session_state.dev_file_loaded:
+        st.sidebar.caption(
+            f"**Data loaded:** {st.session_state.dev_file_name} • "
+            f"{st.session_state.dev_file_rows} rows × {st.session_state.dev_file_cols} cols"
         )
 
-# =========================================================
-# DEVELOPMENT PAGE
-# =========================================================
-if ss.app_step == "dev":
-    render_dev_helper()
-
-    with st.sidebar:
-        st.header("Model Development Data")
-
-        def _on_dev_upload():
-            file = st.session_state.get("dev_upload")
-            if file is not None:
-                ss.dev_bytes = file.getvalue()
-                ss.dev_book  = parse_excel(ss.dev_bytes)
-                ss.dev_previewed = False
-                ss.dev_ran = False
-
-        st.file_uploader("Replace data (Excel)", type=["xlsx","xls"], key="dev_upload",
-                         on_change=_on_dev_upload, help="Limit 200MB per file • XLSX, XLS")
-
-        if ss.dev_bytes and ss.dev_book:
-            # Small status line under upload
-            any_sheet = next(iter(ss.dev_book.values()))
-            st.caption(f"Data loaded: {getattr(st.session_state.get('dev_upload'), 'name', 'file')} • "
-                       f"{any_sheet.shape[0]} rows × {any_sheet.shape[1]} cols")
-
-        preview_clicked = st.button("Preview data", disabled=not bool(ss.dev_book))
-        run_clicked = st.button("Run Model", disabled=not bool(ss.dev_book))
-        proceed_clicked = st.button("Proceed to Prediction ▶", disabled=not ss.get("dev_ran", False))
-
-    # Modal preview (does NOT clear the uploaded file)
-    if preview_clicked and ss.dev_book:
-        with st.modal("Preview data"):
-            st.write("Use the tabs below to inspect the uploaded data before running the model.")
-            preview_modal_dev(ss.dev_book, FEATURES)
-            if st.button("Close", type="primary"):
-                ss.dev_previewed = True
-                st.rerun()
-
-    # Run model
-    if run_clicked and ss.dev_book:
-        # pick sheets
-        book = ss.dev_book
-        low2orig = {k.lower(): k for k in book.keys()}
-        sh_train = None; sh_test=None
-        for nm in ["train","training","training2"]:
-            if nm in low2orig: sh_train = low2orig[nm]; break
-        for nm in ["test","testing","testing2"]:
-            if nm in low2orig: sh_test  = low2orig[nm]; break
-
-        if sh_train is None or sh_test is None:
-            st.error("Workbook must include sheets named *Train/Training* and *Test/Testing* (any one of those).")
+    # Sidebar actions
+    preview_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded)
+    if preview_btn and st.session_state.dev_file_loaded:
+        st.session_state.dev_preview_request = True
+
+    run_btn = st.sidebar.button("Run Model", type="primary", use_container_width=True)
+
+    proceed_clicked = st.sidebar.button(
+        "Proceed to Prediction ▶",
+        use_container_width=True,
+        disabled=not st.session_state.dev_ready
+    )
+    if proceed_clicked and st.session_state.dev_ready:
+        st.session_state.app_step = "predict"; st.rerun()
+
+    # ----- ALWAYS-ON TOP: Title + helper -----
+    helper_top = st.container()
+    with helper_top:
+        st.subheader("Model Development")
+        if st.session_state.dev_ready:
+            st.success("Case has been built and results are displayed below.")
+        elif st.session_state.dev_file_loaded and st.session_state.dev_previewed:
+            st.info("Previewed ✓ — now click **Run Model** to build the case.")
+        elif st.session_state.dev_file_loaded:
+            st.info("📄 **Preview uploaded data** using the sidebar button, then click **Run Model**.")
         else:
-            df_tr = book[sh_train].copy()
-            df_te = book[sh_test].copy()
-            if ensure_cols(df_tr, FEATURES+[TARGET]) and ensure_cols(df_te, FEATURES+[TARGET]):
-                # predict
-                df_tr["UCS_Pred"] = model.predict(df_tr[FEATURES])
-                df_te["UCS_Pred"] = model.predict(df_te[FEATURES])
-                ss.results["Train"] = df_tr
-                ss.results["Test"]  = df_te
-                ss.results["metrics_train"] = {
-                    "R2": r2_score(df_tr[TARGET], df_tr["UCS_Pred"]),
-                    "RMSE": rmse(df_tr[TARGET], df_tr["UCS_Pred"]),
-                    "MAE": mean_absolute_error(df_tr[TARGET], df_tr["UCS_Pred"])
-                }
-                ss.results["metrics_test"]  = {
-                    "R2": r2_score(df_te[TARGET], df_te["UCS_Pred"]),
-                    "RMSE": rmse(df_te[TARGET], df_te["UCS_Pred"]),
-                    "MAE": mean_absolute_error(df_te[TARGET], df_te["UCS_Pred"])
-                }
-                tr_min = df_tr[FEATURES].min().to_dict()
-                tr_max = df_tr[FEATURES].max().to_dict()
-                ss.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
-                ss.dev_ran = True
-                st.rerun()
-
-    # Results (if available)
-    if ss.results.get("Train") is not None or ss.results.get("Test") is not None:
-        tab1, tab2 = st.tabs(["Training", "Testing"])
+            st.write("**Upload your data to build a case, then run the model to review development performance.**")
+
+    # If user clicked preview, open modal *after* helper so helper stays on top
+    if st.session_state.dev_preview_request and st.session_state.dev_file_bytes:
+        _book = read_book_bytes(st.session_state.dev_file_bytes)
+        st.session_state.dev_previewed = True
+        st.session_state.dev_preview_request = False
+        preview_modal_dev(_book, FEATURES)
+
+    # Run model (from persisted bytes)
+    if run_btn and st.session_state.dev_file_bytes:
+        with st.status("Processing…", expanded=False) as status:
+            book = read_book_bytes(st.session_state.dev_file_bytes)
+            if not book: status.update(label="Failed to read workbook.", state="error"); st.stop()
+            status.update(label="Workbook read ✓")
+            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:
+                status.update(label="Workbook must include Train/Training/training2 and Test/Testing/testing2.", state="error"); st.stop()
+            df_tr = book[sh_train].copy(); df_te = book[sh_test].copy()
+            if not (ensure_cols(df_tr, FEATURES + [TARGET]) and ensure_cols(df_te, FEATURES + [TARGET])):
+                status.update(label="Missing required columns.", state="error"); st.stop()
+            status.update(label="Columns validated ✓"); status.update(label="Predicting…")
+
+            df_tr["UCS_Pred"] = model.predict(df_tr[FEATURES])
+            df_te["UCS_Pred"] = model.predict(df_te[FEATURES])
+            st.session_state.results["Train"] = df_tr; st.session_state.results["Test"] = df_te
+
+            st.session_state.results["metrics_train"] = {
+                "R2": r2_score(df_tr[TARGET], df_tr["UCS_Pred"]),
+                "RMSE": rmse(df_tr[TARGET], df_tr["UCS_Pred"]),
+                "MAE": mean_absolute_error(df_tr[TARGET], df_tr["UCS_Pred"]),
+            }
+            st.session_state.results["metrics_test"]  = {
+                "R2": r2_score(df_te[TARGET], df_te["UCS_Pred"]),
+                "RMSE": rmse(df_te[TARGET], df_te["UCS_Pred"]),
+                "MAE": mean_absolute_error(df_te[TARGET], df_te["UCS_Pred"]),
+            }
+
+            tr_min = df_tr[FEATURES].min().to_dict(); tr_max = df_tr[FEATURES].max().to_dict()
+            st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
+
+            st.session_state.dev_ready = True
+            status.update(label="Done ✓", state="complete"); toast("Model run complete 🚀")
+            st.rerun()
 
-        if ss.results.get("Train") is not None:
+    # Results (NOW USING INTERACTIVE PLOTS)
+    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:
-                df = ss.results["Train"]; m = ss.results["metrics_train"]
+                df = st.session_state.results["Train"]; m = st.session_state.results["metrics_train"]
                 c1,c2,c3 = st.columns(3)
-                c1.metric("R²", f"{m['R2']:.4f}")
-                c2.metric("RMSE", f"{m['RMSE']:.4f}")
-                c3.metric("MAE", f"{m['MAE']:.4f}")
-
-                left, right = st.columns([0.58, 0.42])
+                c1.metric("R²", f"{m['R2']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
+                left, right = st.columns([0.9, 0.55])
                 with left:
-                    st.plotly_chart(make_cross_plotly(df[TARGET], df["UCS_Pred"], height=440, width=640),
-                                    use_container_width=True, theme=None)
+                    st.plotly_chart(
+                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], "Training: Actual vs Predicted", size=(3.9,3.9)),
+                        use_container_width=True, config={"displayModeBar": False}
+                    )
                 with right:
-                    st.plotly_chart(make_depth_track_plotly(df, include_actual=True, height=640, width=360),
-                                    use_container_width=True, theme=None)
-
-        if ss.results.get("Test") is not None:
+                    st.plotly_chart(
+                        depth_or_index_track_interactive(df, title=None, include_actual=True),
+                        use_container_width=True, config={"displayModeBar": False}
+                    )
+        if "Test" in st.session_state.results:
             with tab2:
-                df = ss.results["Test"]; m = ss.results["metrics_test"]
+                df = st.session_state.results["Test"]; m = st.session_state.results["metrics_test"]
                 c1,c2,c3 = st.columns(3)
-                c1.metric("R²", f"{m['R2']:.4f}")
-                c2.metric("RMSE", f"{m['RMSE']:.4f}")
-                c3.metric("MAE", f"{m['MAE']:.4f}")
-
-                left, right = st.columns([0.58, 0.42])
+                c1.metric("R²", f"{m['R2']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
+                left, right = st.columns([0.9, 0.55])
                 with left:
-                    st.plotly_chart(make_cross_plotly(df[TARGET], df["UCS_Pred"], height=440, width=640),
-                                    use_container_width=True, theme=None)
+                    st.plotly_chart(
+                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], "Testing: Actual vs Predicted", size=(3.9,3.9)),
+                        use_container_width=True, config={"displayModeBar": False}
+                    )
                 with right:
-                    st.plotly_chart(make_depth_track_plotly(df, include_actual=True, height=640, width=360),
-                                    use_container_width=True, theme=None)
-
-# =========================================================
-# PREDICTION PAGE
-# =========================================================
-if ss.app_step == "dev" and st.sidebar.button("→ Open Prediction in main area", key="force_pred"):
-    ss.app_step = "predict"; st.rerun()
+                    st.plotly_chart(
+                        depth_or_index_track_interactive(df, title=None, include_actual=True),
+                        use_container_width=True, config={"displayModeBar": False}
+                    )
+
+        st.markdown("---")
+        sheets = {}; rows = []
+        if "Train" in st.session_state.results:
+            sheets["Train_with_pred"] = st.session_state.results["Train"]
+            rows.append({"Split":"Train", **{k:round(v,6) for k,v in st.session_state.results["metrics_train"].items()}})
+        if "Test" in st.session_state.results:
+            sheets["Test_with_pred"] = st.session_state.results["Test"]
+            rows.append({"Split":"Test", **{k:round(v,6) for k,v in st.session_state.results["metrics_test"].items()}})
+        summary_df = pd.DataFrame(rows) if rows else None
+        try:
+            data_bytes = export_workbook(sheets, summary_df)
+            st.download_button("Export Development Results to Excel",
+                data=data_bytes, file_name="UCS_Dev_Results.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+        except RuntimeError as e:
+            st.warning(str(e))
+
+# =========================
+# PREDICTION (Validation)
+# =========================
+if st.session_state.app_step == "predict":
+    st.sidebar.header("Prediction (Validation)")
+    validation_file = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"], key="val_upload")
+    if validation_file is not None:
+        _book_tmp = read_book_bytes(validation_file.getvalue())
+        if _book_tmp:
+            first_df = next(iter(_book_tmp.values()))
+            st.sidebar.caption(f"**Data loaded:** {validation_file.name} • {first_df.shape[0]} rows × {first_df.shape[1]} cols")
+
+    preview_val_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=(validation_file is None))
+    if preview_val_btn and validation_file is not None:
+        _book = read_book_bytes(validation_file.getvalue())
+        preview_modal_val(_book, FEATURES)
+
+    predict_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
+    st.sidebar.button("⬅ Back", on_click=lambda: st.session_state.update(app_step="dev"), use_container_width=True)
 
-if ss.app_step == "predict":
     st.subheader("Prediction")
     st.write("Upload a new dataset to generate UCS predictions and evaluate performance on unseen data.")
 
-    with st.sidebar:
-        st.header("Prediction (Validation)")
-        def _on_val_upload():
-            file = st.session_state.get("val_upload")
-            if file is not None:
-                ss.val_bytes = file.getvalue()
-                ss.val_book  = parse_excel(ss.val_bytes)
-
-        st.file_uploader("Upload Validation Excel", type=["xlsx","xls"], key="val_upload", on_change=_on_val_upload)
-        predict_clicked = st.button("Predict", type="primary", use_container_width=True)
-        st.button("⬅ Back", on_click=lambda: ss.update(app_step="dev"))
-
-    if predict_clicked and ss.val_book:
-        vname = list(ss.val_book.keys())[0]
-        df_val = ss.val_book[vname].copy()
-        if not ensure_cols(df_val, FEATURES):
-            st.stop()
-        df_val["UCS_Pred"] = model.predict(df_val[FEATURES])
-        ss.results["Validate"] = df_val
-
-        ranges = ss.train_ranges
-        oor_table = None; oor_pct = 0.0
-        if ranges:
-            viol = {f: (df_val[f] < ranges[f][0]) | (df_val[f] > ranges[f][1]) for f in FEATURES}
-            any_viol = pd.DataFrame(viol).any(axis=1); oor_pct = float(any_viol.mean()*100.0)
-            if any_viol.any():
-                offenders = df_val.loc[any_viol, FEATURES].copy()
-                offenders["Violations"] = pd.DataFrame(viol).loc[any_viol].apply(
-                    lambda r: ", ".join([c for c,v in r.items() if v]), axis=1)
-                offenders.index = offenders.index + 1; oor_table = offenders
-
-        metrics_val = None
-        if TARGET in df_val.columns:
-            metrics_val = {
-                "R2": r2_score(df_val[TARGET], df_val["UCS_Pred"]),
-                "RMSE": rmse(df_val[TARGET], df_val["UCS_Pred"]),
-                "MAE": mean_absolute_error(df_val[TARGET], df_val["UCS_Pred"])
+    if predict_btn and validation_file is not None:
+        with st.status("Predicting…", expanded=False) as status:
+            vbook = read_book_bytes(validation_file.getvalue())
+            if not vbook: status.update(label="Could not read the Validation Excel.", state="error"); st.stop()
+            status.update(label="Workbook read ✓")
+            vname = find_sheet(vbook, ["Validation","Validate","validation2","Val","val"]) or list(vbook.keys())[0]
+            df_val = vbook[vname].copy()
+            if not ensure_cols(df_val, FEATURES): status.update(label="Missing required columns.", state="error"); st.stop()
+            status.update(label="Columns validated ✓")
+            df_val["UCS_Pred"] = model.predict(df_val[FEATURES])
+            st.session_state.results["Validate"] = df_val
+
+            ranges = st.session_state.train_ranges; oor_table = None; oor_pct = 0.0
+            if ranges:
+                viol = {f: (df_val[f] < ranges[f][0]) | (df_val[f] > ranges[f][1]) for f in FEATURES}
+                any_viol = pd.DataFrame(viol).any(axis=1); oor_pct = float(any_viol.mean()*100.0)
+                if any_viol.any():
+                    offenders = df_val.loc[any_viol, FEATURES].copy()
+                    offenders["Violations"] = pd.DataFrame(viol).loc[any_viol].apply(lambda r: ", ".join([c for c,v in r.items() if v]), axis=1)
+                    offenders.index = offenders.index + 1; oor_table = offenders
+
+            metrics_val = None
+            if TARGET in df_val.columns:
+                metrics_val = {
+                    "R2": r2_score(df_val[TARGET], df_val["UCS_Pred"]),
+                    "RMSE": rmse(df_val[TARGET], df_val["UCS_Pred"]),
+                    "MAE": mean_absolute_error(df_val[TARGET], df_val["UCS_Pred"])
+                }
+            st.session_state.results["metrics_val"] = metrics_val
+            st.session_state.results["summary_val"] = {
+                "n_points": len(df_val),
+                "pred_min": float(df_val["UCS_Pred"].min()),
+                "pred_max": float(df_val["UCS_Pred"].max()),
+                "oor_pct": oor_pct
             }
-        ss.results["metrics_val"] = metrics_val
-        ss.results["summary_val"] = {
-            "n_points": len(df_val),
-            "pred_min": float(df_val["UCS_Pred"].min()),
-            "pred_max": float(df_val["UCS_Pred"].max()),
-            "oor_pct": oor_pct
-        }
-        ss.results["oor_table"] = oor_table
-        st.experimental_rerun()
-
-    if ss.results.get("Validate") is not None:
+            st.session_state.results["oor_table"] = oor_table
+            status.update(label="Predictions ready ✓", state="complete")
+
+    if "Validate" in st.session_state.results:
         st.subheader("Validation Results")
-        sv = ss.results["summary_val"]; oor_table = ss.results.get("oor_table")
+        sv = st.session_state.results["summary_val"]; oor_table = st.session_state.results.get("oor_table")
+
+        if sv["oor_pct"] > 0:
+            st.warning("Some validation inputs fall outside the **training min–max** ranges. Interpret predictions with caution.")
+
         c1,c2,c3,c4 = st.columns(4)
-        c1.metric("# points", f"{sv['n_points']}"); c2.metric("Pred min", f"{sv['pred_min']:.2f}")
+        c1.metric("points", f"{sv['n_points']}"); c2.metric("Pred min", f"{sv['pred_min']:.2f}")
         c3.metric("Pred max", f"{sv['pred_max']:.2f}"); c4.metric("OOR %", f"{sv['oor_pct']:.1f}%")
 
-        left,right = st.columns([0.58, 0.42])
+        left, right = st.columns([0.9, 0.55])
         with left:
-            if TARGET in ss.results["Validate"].columns:
+            if TARGET in st.session_state.results["Validate"].columns:
                 st.plotly_chart(
-                    make_cross_plotly(ss.results["Validate"][TARGET], ss.results["Validate"]["UCS_Pred"], height=440, width=640),
-                    use_container_width=True, theme=None
+                    cross_plot_interactive(st.session_state.results["Validate"][TARGET],
+                                           st.session_state.results["Validate"]["UCS_Pred"],
+                                           "Validation: Actual vs Predicted",
+                                           size=(3.9,3.9)),
+                    use_container_width=True, config={"displayModeBar": False}
                 )
             else:
-                st.info("Actual UCS values are not available in the validation data.")
+                st.info("Actual UCS values are not available in the validation data. Cross-plot cannot be generated.")
         with right:
             st.plotly_chart(
-                make_depth_track_plotly(ss.results["Validate"], include_actual=(TARGET in ss.results["Validate"].columns),
-                                        height=640, width=360),
-                use_container_width=True, theme=None
+                depth_or_index_track_interactive(
+                    st.session_state.results["Validate"], title=None,
+                    include_actual=(TARGET in st.session_state.results["Validate"].columns)
+                ),
+                use_container_width=True, config={"displayModeBar": False}
             )
+
         if oor_table is not None:
-            st.warning("Some validation rows contain inputs **outside** the training min–max. Review the table below.")
+            st.write("*Out-of-range rows (vs. Training min–max):*")
             st.dataframe(oor_table, use_container_width=True)
 
-# =========================================================
+        st.markdown("---")
+        sheets = {"Validate_with_pred": st.session_state.results["Validate"]}
+        rows = []
+        for name, key in [("Train","metrics_train"), ("Test","metrics_test"), ("Validate","metrics_val")]:
+            m = st.session_state.results.get(key)
+            if m: rows.append({"Split": name, **{k: round(v,6) for k,v in m.items()}})
+        summary_df = pd.DataFrame(rows) if rows else None
+        try:
+            data_bytes = export_workbook(sheets, summary_df)
+            st.download_button("Export Validation Results to Excel",
+                data=data_bytes, file_name="UCS_Validation_Results.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+        except RuntimeError as e:
+            st.warning(str(e))
+
+# =========================
 # Footer
-# =========================================================
+# =========================
 st.markdown("---")
 st.markdown(
-    "<div style='text-align:center; color:#6b7280;'>"
-    "ST_GeoMech_UCS • © Smart Thinking"
-    "</div>"
-    "<div style='text-align:center; color:#6b7280;'>"
-    "Visit our Website: "
-    "<a href='https://www.smartthinking.com.sa' target='_blank'>smartthinking.com.sa</a>"
-    "</div>",
+    """
+    <div style='text-align:center; color:#6b7280; line-height:1.6'>
+      ST_GeoMech_UCS • © Smart Thinking<br/>
+      <strong>Visit our website:</strong> <a href='https://www.smartthinking.com.sa' target='_blank'>smartthinking.com.sa</a>
+    </div>
+    """,
     unsafe_allow_html=True
 )