Update app.py

app.py

@@ -1,36 +1,63 @@
 # app.py
-import io, json, os, base64
+import io, json, os, base64, math
 from pathlib import Path
 import streamlit as st
 import pandas as pd
 import numpy as np
 import joblib
 
-# keep matplotlib ONLY for the preview modal (static thumbnails)
+# matplotlib only for preview modal thumbnails
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 
 import plotly.graph_objects as go
 from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
-from math import floor, log10
 
 # =========================
-# Defaults
+# 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;}
+      .stApp { background: #FFFFFF; }
+      section[data-testid="stSidebar"] { background: #F6F9FC; }
+      .block-container { padding-top: .5rem; padding-bottom: .5rem; }
+      /* Buttons */
+      .stButton>button{ background:#007bff; color:#fff; font-weight:600;
+                        border-radius:8px; border:none; padding:10px 20px; }
+      .stButton>button:hover{ background:#0056b3; }
+      /* Hero */
+      .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; }
+      [data-testid="stBlock"]{ margin-top:0 !important; }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+# =========================
+# Small constants / 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"]
-
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
+# Fixed plot sizes (tuned to fit without scrolling on typical 14–15" laptops)
+CROSS_W, CROSS_H = 540, 540           # px — square cross-plot
+TRACK_W, TRACK_H = 360, 700           # px — slim & tall track
+
+
 # =========================
-# Page / Theme
+# Helpers (general)
 # =========================
-st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
-
 def inline_logo(path="logo.png") -> str:
     try:
         p = Path(path)
@@ -39,10 +66,72 @@ def inline_logo(path="logo.png") -> str:
     except Exception:
         return ""
 
+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)))
+
+@st.cache_resource(show_spinner=False)
+def load_model(model_path: str):
+    return joblib.load(model_path)
+
+@st.cache_data(show_spinner=False)
+def parse_excel(data_bytes: bytes):
+    bio = io.BytesIO(data_bytes)
+    xl = pd.ExcelFile(bio)
+    return {sh: xl.parse(sh) for sh in xl.sheet_names}
+
+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 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 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 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
+    return None
+
+def compute_tick_step(lo, hi, target_ticks=6):
+    rng = max(hi - lo, 1.0)
+    raw = rng / target_ticks
+    power = 10 ** math.floor(math.log10(raw))
+    mult = round(raw / power)
+    step = mult * power
+    # snap to 50/100/200 etc for tidier thousands
+    if step >= 50 and step % 50 != 0:
+        step = round(step / 50) * 50
+    return step
+
+
 # =========================
-# Password (brand-gated)
+# Password Gate (define FIRST, then call)
 # =========================
 def add_password_gate() -> bool:
+    """Branded password screen. Requires APP_PASSWORD in Secrets/Env."""
+    required = ""
     try:
         required = st.secrets.get("APP_PASSWORD", "")
     except Exception:
@@ -60,8 +149,7 @@ def add_password_gate() -> bool:
             </div>
             <div style="font-size:1.25rem;font-weight:700;margin:8px 0 4px 0;">Protected Area</div>
             <div style="color:#6b7280;margin-bottom:14px;">
-              Admin action required: set <code>APP_PASSWORD</code> in <b>Settings → Secrets</b>
-              (or as an environment variable) and restart the Space.
+              Admin action required: set <code>APP_PASSWORD</code> in <b>Settings → Secrets</b>, then restart the Space.
             </div>
             """,
             unsafe_allow_html=True,
@@ -81,9 +169,7 @@ def add_password_gate() -> bool:
           </div>
         </div>
         <div style="font-size:1.25rem;font-weight:700;margin:8px 0 4px 0;">Protected</div>
-        <div style="color:#6b7280;margin-bottom:14px;">
-          Please enter your access key to continue.
-        </div>
+        <div style="color:#6b7280;margin-bottom:14px;">Please enter your access key to continue.</div>
         """,
         unsafe_allow_html=True
     )
@@ -98,102 +184,22 @@ def add_password_gate() -> bool:
                 st.error("Incorrect key. Please try again.")
     st.stop()
 
+# 🔒 Invoke password gate
 add_password_gate()
 
-# CSS
-st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
-st.markdown(
-    """
-    <style>
-    .stApp { background: #FFFFFF; }
-    section[data-testid="stSidebar"] { background: #F6F9FC; }
-    .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; }
-    [data-testid="stBlock"]{ margin-top:0 !important; }
-    </style>
-    """,
-    unsafe_allow_html=True
-)
 
 # =========================
-# Helpers
+# Interactive plots
 # =========================
-try:
-    dialog = st.dialog
-except AttributeError:
-    def dialog(title):
-        def deco(fn):
-            def wrapper(*args, **kwargs):
-                with st.expander(title, expanded=True):
-                    return fn(*args, **kwargs)
-            return wrapper
-        return deco
-
-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)
-
-@st.cache_data(show_spinner=False)
-def parse_excel(data_bytes: bytes):
-    bio = io.BytesIO(data_bytes)
-    xl = pd.ExcelFile(bio)
-    return {sh: xl.parse(sh) for sh in xl.sheet_names}
-
-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 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
-
-# ----- Nice tick step for cross-plot -----
-def _nice_dtick(data_range: float) -> float:
-    if data_range <= 0 or np.isnan(data_range): return 1.0
-    raw = data_range / 6.0  # aim ~6 ticks
-    k = floor(log10(raw))
-    base = 10 ** k
-    m = raw / base
-    if m <= 1.5:
-        step = 1 * base
-    elif m <= 3.5:
-        step = 2 * base
-    elif m <= 7.5:
-        step = 5 * base
-    else:
-        step = 10 * base
-    return step
-
-# ---------- Interactive plotting ----------
-def cross_plot_interactive(actual, pred, size=(3.9, 3.9)):
+def cross_plot_interactive(actual, pred, width=CROSS_W, height=CROSS_H):
+    """Fixed-size square cross-plot, 1:1 axes, tidy ticks, full outline."""
     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)
+    pad = 0.04 * (hi - lo if hi > lo else 1.0)
     x0, x1 = lo - pad, hi + pad
-    dtick = _nice_dtick(x1 - x0)
+    step = compute_tick_step(x0, x1)
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -208,30 +214,28 @@ def cross_plot_interactive(actual, pred, size=(3.9, 3.9)):
         hoverinfo="skip", showlegend=False
     ))
     fig.update_layout(
+        width=width, height=height, title=None,
         paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
-        margin=dict(l=50, r=10, t=10, b=36),
-        hovermode="closest", font=dict(size=13), dragmode="zoom"
+        margin=dict(l=60, r=20, t=10, b=50),
+        hovermode="closest", font=dict(size=13)
     )
     fig.update_xaxes(
-        title_text="<b>Actual UCS</b>",
-        range=[x0, x1], tickmode="linear", dtick=dtick, ticks="outside",
+        title_text="<b>Actual UCS</b>", range=[x0, x1], dtick=step,
+        ticks="outside", tickformat=",.0f",
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        tickformat=",.0f", automargin=True
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
     fig.update_yaxes(
-        title_text="<b>Predicted UCS</b>",
-        range=[x0, x1], tickmode="linear", dtick=dtick, ticks="outside",
+        title_text="<b>Predicted UCS</b>", range=[x0, x1], dtick=step,
+        ticks="outside", tickformat=",.0f",
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        tickformat=",.0f", scaleanchor="x", scaleratio=1,
-        automargin=True
+        scaleanchor="x", scaleratio=1, automargin=True
     )
-    w = int(size[0] * 100); h = int(size[1] * 100)
-    fig.update_layout(width=w, height=h)
     return fig
 
-def depth_or_index_track_interactive(df, title=None, include_actual=True, x_range=None):
+def depth_or_index_track_interactive(df, include_actual=True, width=TRACK_W, height=TRACK_H):
+    """Tall & slim track; legend inside; x on top; full outline; reversed 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
@@ -252,38 +256,46 @@ def depth_or_index_track_interactive(df, title=None, include_actual=True, x_rang
             name="UCS (actual)",
             hovertemplate="UCS (actual): %{x:.0f}<br>"+y_label+": %{y}<extra></extra>"
         ))
-
-    # slimmer & taller like a log profile
     fig.update_layout(
+        width=width, height=height,
         paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
-        margin=dict(l=60, r=10, t=10, b=36),
+        margin=dict(l=60, r=10, t=10, b=40),
         hovermode="closest", font=dict(size=13),
         legend=dict(
             x=0.98, y=0.05, xanchor="right", yanchor="bottom",
             bgcolor="rgba(255,255,255,0.75)", bordercolor="#cccccc", borderwidth=1
         ),
-        legend_title_text="",
-        width=int(2.4 * 100),   # narrower
-        height=int(8.4 * 100),  # taller
-        dragmode="zoom"
+        legend_title_text=""
     )
     fig.update_xaxes(
         title_text="<b>UCS</b>", side="top",
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        tickformat=",.0f",
-        automargin=True,
-        range=x_range
+        ticks="outside", tickformat=",.0f",
+        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=f"<b>{y_label}</b>", autorange="reversed",
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        automargin=True
+        ticks="outside",
+        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
     return fig
 
-# ---------- Preview modal helpers (matplotlib static) ----------
+
+# =========================
+# Preview modals (matplotlib)
+# =========================
+try:
+    dialog = st.dialog
+except AttributeError:
+    def dialog(title):
+        def deco(fn):
+            def wrapper(*args, **kwargs):
+                with st.expander(title, expanded=True):
+                    return fn(*args, **kwargs)
+            return wrapper
+        return deco
+
 def make_index_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
@@ -313,37 +325,24 @@ def stats_table(df: pd.DataFrame, cols: list[str]) -> pd.DataFrame:
     return out.reset_index().rename(columns={"index": "Feature"})
 
 @dialog("Preview data")
-def preview_modal_dev(book: dict[str, pd.DataFrame], feature_cols: list[str]):
+def preview_modal(book: dict[str, pd.DataFrame], feature_cols: list[str], sheet_names):
     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:
+    resolved = [find_sheet(book, [nm]) for nm in sheet_names]
+    existing = [(nm, book[nm]) for nm in resolved if nm is not None]
+    if not existing:
         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):
+        existing = [(first_name, book[first_name])]
+    tabs = st.tabs([nm for nm,_ in existing])
+    for t,(nm,df) in zip(tabs, existing):
         with t:
-            t1, t2 = st.tabs(["Tracks", "Summary"])
+            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 loading (includes optional remote download)
 # =========================
 MODEL_URL = _get_model_url()
 
@@ -384,24 +383,12 @@ 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
+    except Exception: pass
 else:
-    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
-        return None
     infer = infer_features_from_model(model)
     if infer: FEATURES = infer
 
+
 # =========================
 # Session state
 # =========================
@@ -409,17 +396,21 @@ 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/Val/Pred state
-defaults = {
-    "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,
-    "val_file_bytes": b"", "val_file_loaded": False, "val_preview_request": False,
-    "pred_file_bytes": b"", "pred_file_loaded": False, "pred_preview_request": False,
-}
-for k, v in defaults.items():
+# persist dev upload
+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
 # =========================
@@ -436,12 +427,15 @@ st.markdown(
     unsafe_allow_html=True,
 )
 
+
 # =========================
-# INTRO PAGE
+# INTRO
 # =========================
 if st.session_state.app_step == "intro":
     st.header("Welcome!")
-    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate UCS from drilling data.")
+    st.markdown(
+        "This software is developed by *Smart Thinking AI-Solutions Team* to estimate UCS from drilling data."
+    )
     st.subheader("Expected Input Features (in Order)")
     st.markdown(
         "- Q, gpm — Flow rate (gallons per minute)  \n"
@@ -450,28 +444,29 @@ if st.session_state.app_step == "intro":
         "- WOB (klbf) — Weight on bit  \n"
         "- ROP (ft/h) — Rate of penetration"
     )
-    st.subheader("How It Works")
+    st.subheader("Process")
     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 Validation** to evaluate on a new dataset with actual UCS (if available).  \n"
-        "4. Click **Proceed to Prediction** to generate production predictions (no actuals).  \n"
-        "5. Export results to Excel at any time."
+        "1) **Case Building**: Upload your data, preview, then run the model.  \n"
+        "2) **Validate the Model**: Upload a validation dataset (with actual UCS) to evaluate performance.  \n"
+        "3) **Prediction**: Upload a production dataset (no UCS target) to get predictions."
     )
-    if st.button("Start Showcase", type="primary", key="start_showcase"):
+    if st.button("Start Showcase", type="primary"):
         st.session_state.app_step = "dev"; st.rerun()
 
+
 # =========================
-# 1) CASE BUILDING (Development)
+# CASE BUILDING (Development)
 # =========================
 if st.session_state.app_step == "dev":
     st.sidebar.header("Case Building (Development)")
-    dev_label = "Upload Data (Excel)" if not st.session_state.dev_file_name else "Replace data (Excel)"
+    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")
 
+    # Persist upload
     if train_test_file is not None:
         try:
-            file_bytes = train_test_file.getvalue(); size = len(file_bytes)
+            file_bytes = train_test_file.getvalue()
+            size = len(file_bytes)
         except Exception:
             file_bytes = b""; size = 0
         sig = (train_test_file.name, size)
@@ -494,37 +489,35 @@ if st.session_state.app_step == "dev":
             f"{st.session_state.dev_file_rows} rows × {st.session_state.dev_file_cols} cols"
         )
 
-    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:
+    # Always-on navigation
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=not 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)
-
-    # jump links
-    proceed_val = st.sidebar.button("Proceed to Validation ▶", use_container_width=True)
-    proceed_pred = st.sidebar.button("Proceed to Prediction ▶", use_container_width=True)
-    if proceed_val:
+    # Enabled always so users can jump ahead
+    if st.sidebar.button("Proceed to Validation ▶", use_container_width=True):
         st.session_state.app_step = "validate"; st.rerun()
-    if proceed_pred:
+    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
         st.session_state.app_step = "predict"; st.rerun()
 
-    with st.container():
-        st.subheader("Case Building")
-        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:
-            st.write("**Upload your data to build a case, then run the model to review development performance.**")
+    # Helper text
+    st.subheader("Case Building (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:
+        st.write("**Upload your data to build a case, then run the model to review development performance.**")
 
+    # Preview modal
     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)
+        preview_modal(_book, FEATURES, sheet_names=["Train","Test"])
 
+    # Run model
     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)
@@ -533,7 +526,7 @@ if st.session_state.app_step == "dev":
             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()
+                status.update(label="Workbook must include Train... and Test...", 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()
@@ -553,70 +546,42 @@ if st.session_state.app_step == "dev":
                 "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"); st.rerun()
 
+    # Results
     if ("Train" in st.session_state.results) or ("Test" in st.session_state.results):
         tab1, tab2 = st.tabs(["Training", "Testing"])
+        cfg = {"displayModeBar": False, "scrollZoom": True}
+
         if "Train" in st.session_state.results:
             with tab1:
                 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.9, 0.55])
+                left, right = st.columns([1.0, 0.7])
                 with left:
-                    st.plotly_chart(
-                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], size=(3.9,3.9)),
-                        use_container_width=True, config={"displayModeBar": False}
-                    )
+                    st.plotly_chart(cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
+                                    use_container_width=False, config=cfg)
                 with right:
-                    # Zoom control for UCS axis
-                    pr_min = float(df["UCS_Pred"].min())
-                    xs = [pr_min]
-                    if TARGET in df: xs.append(float(df[TARGET].min()))
-                    x_min = min(xs)
-                    pr_max = float(df["UCS_Pred"].max())
-                    xs = [pr_max]
-                    if TARGET in df: xs.append(float(df[TARGET].max()))
-                    x_max = max(xs)
-                    with st.expander("Zoom (UCS axis)", expanded=False):
-                        z = st.slider("UCS range", min_value=float(x_min), max_value=float(x_max),
-                                      value=(float(x_min), float(x_max)), step=10.0, key="zoom_train")
-                    st.plotly_chart(
-                        depth_or_index_track_interactive(df, title=None, include_actual=True, x_range=z),
-                        use_container_width=True, config={"displayModeBar": False}
-                    )
+                    st.plotly_chart(depth_or_index_track_interactive(df, include_actual=True),
+                                    use_container_width=False, config=cfg)
+
         if "Test" in st.session_state.results:
             with tab2:
                 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.9, 0.55])
+                left, right = st.columns([1.0, 0.7])
                 with left:
-                    st.plotly_chart(
-                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], size=(3.9,3.9)),
-                        use_container_width=True, config={"displayModeBar": False}
-                    )
+                    st.plotly_chart(cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
+                                    use_container_width=False, config=cfg)
                 with right:
-                    pr_min = float(df["UCS_Pred"].min())
-                    xs = [pr_min]
-                    if TARGET in df: xs.append(float(df[TARGET].min()))
-                    x_min = min(xs)
-                    pr_max = float(df["UCS_Pred"].max())
-                    xs = [pr_max]
-                    if TARGET in df: xs.append(float(df[TARGET].max()))
-                    x_max = max(xs)
-                    with st.expander("Zoom (UCS axis)", expanded=False):
-                        z2 = st.slider("UCS range", min_value=float(x_min), max_value=float(x_max),
-                                       value=(float(x_min), float(x_max)), step=10.0, key="zoom_test")
-                    st.plotly_chart(
-                        depth_or_index_track_interactive(df, title=None, include_actual=True, x_range=z2),
-                        use_container_width=True, config={"displayModeBar": False}
-                    )
+                    st.plotly_chart(depth_or_index_track_interactive(df, include_actual=True),
+                                    use_container_width=False, config=cfg)
 
         st.markdown("---")
         sheets = {}; rows = []
@@ -643,48 +608,38 @@ if st.session_state.app_step == "dev":
         except Exception as e:
             st.warning(str(e))
 
+
 # =========================
-# 2) VALIDATE THE MODEL
+# VALIDATE THE MODEL
 # =========================
 if st.session_state.app_step == "validate":
-    st.sidebar.header("Validate the model")
+    st.sidebar.header("Validate the Model")
     validation_file = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"], key="val_upload")
-
     if validation_file is not None:
-        st.session_state.val_file_bytes = validation_file.getvalue()
-        _book_tmp = read_book_bytes(st.session_state.val_file_bytes)
+        _book_tmp = read_book_bytes(validation_file.getvalue())
         if _book_tmp:
             first_df = next(iter(_book_tmp.values()))
-            st.session_state.val_file_loaded = True
             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=not st.session_state.val_file_loaded)
-    if preview_val_btn and st.session_state.val_file_loaded:
-        st.session_state.val_preview_request = True
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=(validation_file is None)):
+        _book = read_book_bytes(validation_file.getvalue())
+        preview_modal(_book, FEATURES, sheet_names=["Validation","Val","Validate"])
 
     predict_btn = st.sidebar.button("Run Validation", type="primary", use_container_width=True)
-    proceed_pred = st.sidebar.button("Proceed to Prediction ▶", use_container_width=True)
     st.sidebar.button("⬅ Back to Case Building", on_click=lambda: st.session_state.update(app_step="dev"), use_container_width=True)
-    if proceed_pred:
-        st.session_state.app_step = "predict"; st.rerun()
+    st.sidebar.button("Proceed to Prediction ▶", on_click=lambda: st.session_state.update(app_step="predict"), use_container_width=True)
 
-    with st.container():
-        st.subheader("Validate the model")
-        st.write("Upload a validation dataset (with actual UCS if available), preview it, then run to view metrics and plots.")
+    st.subheader("Validate the Model")
+    st.write("Upload a dataset with **actual UCS** to evaluate model performance on unseen data.")
 
-    if st.session_state.val_preview_request and st.session_state.val_file_bytes:
-        _book = read_book_bytes(st.session_state.val_file_bytes)
-        st.session_state.val_preview_request = False
-        preview_modal_val(_book, FEATURES)
-
-    if predict_btn and st.session_state.val_file_bytes:
+    if predict_btn and validation_file is not None:
         with st.status("Validating…", expanded=False) as status:
-            vbook = read_book_bytes(st.session_state.val_file_bytes)
+            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()
+            if not ensure_cols(df_val, FEATURES + [TARGET]): 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
@@ -698,13 +653,11 @@ if st.session_state.app_step == "validate":
                     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"])
-                }
+            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),
@@ -713,71 +666,34 @@ if st.session_state.app_step == "validate":
                 "oor_pct": oor_pct
             }
             st.session_state.results["oor_table"] = oor_table
-            status.update(label="Validation ready ✓", state="complete")
+            status.update(label="Predictions ready ✓", state="complete")
 
     if "Validate" in st.session_state.results:
-        sv = st.session_state.results["summary_val"]; oor_table = st.session_state.results.get("oor_table")
-
+        cfg = {"displayModeBar": False, "scrollZoom": True}
+        df = st.session_state.results["Validate"]
+        m = st.session_state.results.get("metrics_val"); sv = st.session_state.results["summary_val"]
         if sv["oor_pct"] > 0:
             st.warning("Some validation inputs fall outside the **training min–max** ranges. Interpret predictions with caution.")
+        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}")
 
-        metrics_val = st.session_state.results.get("metrics_val")
-        if metrics_val is not None:
-            c1, c2, c3 = st.columns(3)
-            c1.metric("R²",   f"{metrics_val['R2']:.4f}")
-            c2.metric("RMSE", f"{metrics_val['RMSE']:.4f}")
-            c3.metric("MAE",  f"{metrics_val['MAE']:.4f}")
-        else:
-            c1, c2, c3 = st.columns(3)
-            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}")
-
-        left, right = st.columns([0.9, 0.55])
+        left, right = st.columns([1.0, 0.7])
         with left:
-            if TARGET in st.session_state.results["Validate"].columns:
-                st.plotly_chart(
-                    cross_plot_interactive(
-                        st.session_state.results["Validate"][TARGET],
-                        st.session_state.results["Validate"]["UCS_Pred"],
-                        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. Cross-plot cannot be generated.")
+            st.plotly_chart(cross_plot_interactive(df[TARGET], df["UCS_Pred"]), use_container_width=False, config=cfg)
         with right:
-            df = st.session_state.results["Validate"]
-            pr_min = float(df["UCS_Pred"].min())
-            xs = [pr_min]
-            if TARGET in df: xs.append(float(df[TARGET].min()))
-            x_min = min(xs)
-            pr_max = float(df["UCS_Pred"].max())
-            xs = [pr_max]
-            if TARGET in df: xs.append(float(df[TARGET].max()))
-            x_max = max(xs)
-            with st.expander("Zoom (UCS axis)", expanded=False):
-                zv = st.slider("UCS range", min_value=float(x_min), max_value=float(x_max),
-                               value=(float(x_min), float(x_max)), step=10.0, key="zoom_val")
-            st.plotly_chart(
-                depth_or_index_track_interactive(
-                    df, title=None,
-                    include_actual=(TARGET in df.columns),
-                    x_range=zv
-                ),
-                use_container_width=True, config={"displayModeBar": False}
-            )
+            st.plotly_chart(depth_or_index_track_interactive(df, include_actual=True), use_container_width=False, config=cfg)
 
-        if oor_table is not None:
+        if st.session_state.results.get("oor_table") is not None:
             st.write("*Out-of-range rows (vs. Training min–max):*")
-            st.dataframe(oor_table, use_container_width=True)
+            st.dataframe(st.session_state.results["oor_table"], use_container_width=True)
 
+        # Export
         st.markdown("---")
-        sheets = {"Validate_with_pred": st.session_state.results["Validate"]}
+        sheets = {"Validate_with_pred": df}
         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()}})
+            mm = st.session_state.results.get(key)
+            if mm: rows.append({"Split": name, **{k: round(v,6) for k,v in mm.items()}})
         summary_df = pd.DataFrame(rows) if rows else None
         try:
             buf = io.BytesIO()
@@ -795,114 +711,86 @@ if st.session_state.app_step == "validate":
         except Exception as e:
             st.warning(str(e))
 
+        # OOR footnote
+        st.caption("**★ OOR %**: fraction of rows with any input feature outside the training min–max ranges.")
+
+
 # =========================
-# 3) PREDICTION (no actual UCS)
+# PREDICTION (no actual UCS)
 # =========================
 if st.session_state.app_step == "predict":
     st.sidebar.header("Prediction")
-    pred_file = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"], key="pred_upload")
-
+    pred_file = st.sidebar.file_uploader("Upload Production Excel", type=["xlsx","xls"], key="pred_upload")
     if pred_file is not None:
-        st.session_state.pred_file_bytes = pred_file.getvalue()
-        _book_tmp = read_book_bytes(st.session_state.pred_file_bytes)
+        _book_tmp = read_book_bytes(pred_file.getvalue())
         if _book_tmp:
             first_df = next(iter(_book_tmp.values()))
-            st.session_state.pred_file_loaded = True
             st.sidebar.caption(f"**Data loaded:** {pred_file.name} • {first_df.shape[0]} rows × {first_df.shape[1]} cols")
 
-    preview_pred_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.pred_file_loaded)
-    if preview_pred_btn and st.session_state.pred_file_loaded:
-        st.session_state.pred_preview_request = True
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=(pred_file is None)):
+        _book = read_book_bytes(pred_file.getvalue())
+        preview_modal(_book, FEATURES, sheet_names=["Prediction","Pred"])
 
-    predict_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
+    run_pred = st.sidebar.button("Predict", type="primary", use_container_width=True)
     st.sidebar.button("⬅ Back to Validation", on_click=lambda: st.session_state.update(app_step="validate"), use_container_width=True)
+    st.sidebar.button("⬅ Back to Case Building", on_click=lambda: st.session_state.update(app_step="dev"), use_container_width=True)
 
-    with st.container():
-        st.subheader("Prediction")
-        st.write("Upload a dataset (no actual UCS needed), preview it, then click **Predict** to generate UCS estimates.")
-
-    if st.session_state.pred_preview_request and st.session_state.pred_file_bytes:
-        _book = read_book_bytes(st.session_state.pred_file_bytes)
-        st.session_state.pred_preview_request = False
-        preview_modal_val(_book, FEATURES)
+    st.subheader("Prediction")
+    st.write("Upload a production dataset (**without UCS target**) to generate predictions.")
 
-    if predict_btn and st.session_state.pred_file_bytes:
+    if run_pred and pred_file is not None:
         with st.status("Predicting…", expanded=False) as status:
-            pbook = read_book_bytes(st.session_state.pred_file_bytes)
-            if not pbook: status.update(label="Could not read the Excel file.", state="error"); st.stop()
+            pbook = read_book_bytes(pred_file.getvalue())
+            if not pbook: status.update(label="Could not read the Excel.", state="error"); st.stop()
             status.update(label="Workbook read ✓")
-            pname = list(pbook.keys())[0]
-            df_pred = pbook[pname].copy()
-            if not ensure_cols(df_pred, FEATURES): status.update(label="Missing required columns.", state="error"); st.stop()
+            pname = find_sheet(pbook, ["Prediction","Pred"]) or list(pbook.keys())[0]
+            dfp = pbook[pname].copy()
+            if not ensure_cols(dfp, FEATURES): status.update(label="Missing required columns.", state="error"); st.stop()
             status.update(label="Columns validated ✓")
-            df_pred["UCS_Pred"] = model.predict(df_pred[FEATURES])
-            st.session_state.results["Prediction"] = df_pred
+            dfp["UCS_Pred"] = model.predict(dfp[FEATURES])
+            st.session_state.results["Prod"] = dfp
 
-            ranges = st.session_state.train_ranges; oor_table = None; oor_pct = 0.0
+            ranges = st.session_state.train_ranges; oor_pct = 0.0
             if ranges:
-                viol = {f: (df_pred[f] < ranges[f][0]) | (df_pred[f] > ranges[f][1]) for f in FEATURES}
+                viol = {f: (dfp[f] < ranges[f][0]) | (dfp[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_pred.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
-
-            st.session_state.results["summary_pred"] = {
-                "n_points": len(df_pred),
-                "pred_min": float(df_pred["UCS_Pred"].min()),
-                "pred_max": float(df_pred["UCS_Pred"].max()),
-                "pred_mean": float(df_pred["UCS_Pred"].mean()),
-                "pred_std": float(df_pred["UCS_Pred"].std(ddof=0)),
+            st.session_state.results["summary_prod"] = {
+                "n_points": len(dfp),
+                "pred_min": float(dfp["UCS_Pred"].min()),
+                "pred_max": float(dfp["UCS_Pred"].max()),
+                "pred_mean": float(dfp["UCS_Pred"].mean()),
+                "pred_std": float(dfp["UCS_Pred"].std(ddof=0)),
                 "oor_pct": oor_pct
             }
-            st.session_state.results["oor_table_pred"] = oor_table
             status.update(label="Predictions ready ✓", state="complete")
 
-    if "Prediction" in st.session_state.results:
-        sv = st.session_state.results["summary_pred"]
-        if sv.get("oor_pct", 0) > 0:
-            st.warning("Some inputs fall outside the **training min–max** ranges. Interpret predictions with caution.")
+    if "Prod" in st.session_state.results:
+        cfg = {"displayModeBar": False, "scrollZoom": True}
+        dfp = st.session_state.results["Prod"]
+        sv = st.session_state.results["summary_prod"]
 
-        left, right = st.columns([0.6, 0.9])
+        # Small summary table on the LEFT (where cross-plot would be)
+        left, right = st.columns([0.7, 1.0])
         with left:
-            table = pd.DataFrame(
-                {
-                    "Metric": ["# points", "Pred min", "Pred max", "Pred mean", "Pred std", "OOR %"],
-                    "Value": [
-                        f"{sv['n_points']}",
-                        f"{sv['pred_min']:.2f}",
-                        f"{sv['pred_max']:.2f}",
-                        f"{sv['pred_mean']:.2f}",
-                        f"{sv['pred_std']:.2f}",
-                        f"{sv['oor_pct']:.1f}%",
-                    ],
-                }
-            )
-            st.dataframe(table, use_container_width=True, hide_index=True)
-            # ★ footnote under table
-            st.caption("★ OOR % = percentage of rows where at least one input feature is outside the training set's min–max range.")
+            tbl = pd.DataFrame({
+                "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
+                "Value": [sv["n_points"], sv["pred_min"], sv["pred_max"], sv["pred_mean"], sv["pred_std"], sv["oor_pct"]]
+            })
+            st.dataframe(tbl, use_container_width=True)
+            st.caption("**★ OOR %**: fraction of rows with any input feature outside the training min–max ranges.")
+
         with right:
-            # Optional zoom
-            dfp = st.session_state.results["Prediction"]
-            pmin, pmax = float(dfp["UCS_Pred"].min()), float(dfp["UCS_Pred"].max())
-            with st.expander("Zoom (UCS axis)", expanded=False):
-                zp = st.slider("UCS range", min_value=pmin, max_value=pmax, value=(pmin, pmax), step=10.0, key="zoom_pred")
             st.plotly_chart(
-                depth_or_index_track_interactive(
-                    dfp, title=None, include_actual=False, x_range=zp
-                ),
-                use_container_width=True, config={"displayModeBar": False}
+                depth_or_index_track_interactive(dfp, include_actual=False),
+                use_container_width=False, config=cfg
             )
 
-        if st.session_state.results.get("oor_table_pred") is not None:
-            st.write("*Out-of-range rows (vs. Training min–max):*")
-            st.dataframe(st.session_state.results["oor_table_pred"], use_container_width=True)
-
+        # Export
         st.markdown("---")
         try:
             buf = io.BytesIO()
             with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                st.session_state.results["Prediction"].to_excel(xw, sheet_name="Prediction_with_pred", index=False)
+                dfp.to_excel(xw, sheet_name="Prediction_with_UCS_Pred", index=False)
                 pd.DataFrame([sv]).to_excel(xw, sheet_name="Summary", index=False)
             st.download_button(
                 "Export Prediction Results to Excel",
@@ -913,6 +801,7 @@ if st.session_state.app_step == "predict":
         except Exception as e:
             st.warning(str(e))
 
+
 # =========================
 # Footer
 # =========================