Update app.py

app.py

@@ -6,7 +6,7 @@ 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
@@ -14,40 +14,74 @@ import matplotlib.pyplot as plt
 import plotly.graph_objects as go
 from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
 
-# =========================
-# Fixed plot sizes (px)
-# =========================
-CROSS_W, CROSS_H = 390, 390            # cross-plot (square & compact)
-TRACK_W, TRACK_H = 220, 700            # EXACT match to preview strips (≈ 2.2in × 7.0in @100dpi)
 
 # =========================
-# Defaults
+# Defaults / Constants
 # =========================
 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"}
 
-# ------------------------------------------------------------
-# Small utilities that must exist before we use them
-# ------------------------------------------------------------
+# Fixed pixel sizes to keep appearance stable across pages
+CROSS_W, CROSS_H = 390, 390          # cross-plot = square
+TRACK_W, TRACK_H = 220, 700          # slim/tall log-style track
+
+
+# =========================
+# 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; }
+      .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; }
+      .help-foot { color:#6b7280; font-size:0.95rem; }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+
+# =========================
+# Small helpers (used by password gate too)
+# =========================
 def inline_logo(path="logo.png") -> str:
     try:
         p = Path(path)
-        if not p.exists(): return ""
+        if not p.exists():
+            return ""
         return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
     except Exception:
         return ""
 
+
+# =========================
+# Password gate (branded)
+# =========================
 def add_password_gate() -> bool:
     """
-    Branded password screen until APP_PASSWORD is provided.
-    Set APP_PASSWORD in HF Space: Settings → Secrets.
+    Ask for a password (APP_PASSWORD in Secrets or Env) before rendering the app.
+    If not configured, block with a clear admin message.
     """
-    # Read password from secrets or env
+    # pull required password
     required = ""
     try:
         required = st.secrets.get("APP_PASSWORD", "")
@@ -66,7 +100,8 @@ 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> then restart the Space.
+              Admin action required: set <code>APP_PASSWORD</code> in <b>Settings → Secrets</b> (or as an
+              environment variable) and restart the Space.
             </div>
             """,
             unsafe_allow_html=True,
@@ -86,51 +121,26 @@ 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
     )
-
     pwd = st.text_input("Access key", type="password", placeholder="••••••••")
-    col1, _ = st.columns([1, 3])
-    with col1:
-        if st.button("Unlock", type="primary", use_container_width=True):
-            if pwd == required:
-                st.session_state.auth_ok = True
-                st.rerun()
-            else:
-                st.error("Incorrect key. Please try again.")
+    if st.button("Unlock", type="primary"):
+        if pwd == required:
+            st.session_state.auth_ok = True
+            st.rerun()
+        else:
+            st.error("Incorrect key. Please try again.")
     st.stop()
 
-# =========================
-# Page / Theme
-# =========================
-st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
-add_password_gate()   # 🔒 gate
 
-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
-)
+# Call the password gate before anything else is drawn
+add_password_gate()
+
 
 # =========================
-# Helpers
+# General helpers
 # =========================
 try:
     dialog = st.dialog
@@ -167,19 +177,28 @@ def parse_excel(data_bytes: bytes):
 
 def read_book_bytes(data_bytes: bytes):
     if not data_bytes: return {}
-    try: return parse_excel(data_bytes)
+    try:
+        return parse_excel(data_bytes)
     except Exception as e:
-        st.error(f"Failed to read Excel: {e}"); return {}
+        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()]
+        if nm.lower() in low2orig:
+            return low2orig[nm.lower()]
     return None
 
-# ---------- Interactive plotting (fixed sizes, full outline) ----------
+
+# ---------- Plot helpers (interactive, fixed size, full outline) ----------
+def _add_full_frame(fig):
+    fig.update_layout(shapes=[dict(
+        type="rect", xref="paper", yref="paper", x0=0, y0=0, x1=1, y1=1,
+        line=dict(color="#444", width=1), fillcolor="rgba(0,0,0,0)"
+    )])
+
 def cross_plot_interactive(actual, pred):
-    """Interactive cross-plot: blue points, dashed 1:1, equal axes, NO title, full outline."""
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
     lo = float(np.nanmin([a.min(), p.min()]))
@@ -207,24 +226,20 @@ def cross_plot_interactive(actual, pred):
         width=CROSS_W, height=CROSS_H
     )
     fig.update_xaxes(
-        title_text="<b>Actual UCS</b>",
-        range=[x0, x1], ticks="outside",
-        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        tickformat=",.0f", automargin=True
+        title_text="<b>Actual UCS</b>", range=[x0, x1], tickformat=",.0f",
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
     fig.update_yaxes(
-        title_text="<b>Predicted UCS</b>",
-        range=[x0, x1], ticks="outside",
-        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        tickformat=",.0f", scaleanchor="x", scaleratio=1,
+        title_text="<b>Predicted UCS</b>", range=[x0, x1], tickformat=",.0f",
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", scaleanchor="x", scaleratio=1,
         automargin=True
     )
+    _add_full_frame(fig)
     return fig
 
 def depth_or_index_track_interactive(df, include_actual=True):
-    """Interactive UCS track: fixed width/height EXACTLY like preview strips."""
     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
@@ -232,15 +247,12 @@ def depth_or_index_track_interactive(df, include_actual=True):
         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=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=y, mode="lines",
@@ -251,29 +263,27 @@ def depth_or_index_track_interactive(df, include_actual=True):
 
     fig.update_layout(
         paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
-        margin=dict(l=44, r=6, t=6, b=36),   # slim margins like preview
+        margin=dict(l=44, r=6, t=6, b=36),
         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=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=TRACK_W, height=TRACK_H
     )
     fig.update_xaxes(
-        title_text="<b>UCS</b>", side="top",
+        title_text="<b>UCS</b>", side="top", tickformat=",.0f",
         ticks="outside", 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=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
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
+    _add_full_frame(fig)
     return fig
 
+
 # ---------- Preview modal helpers (matplotlib static) ----------
 def make_index_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
@@ -315,24 +325,24 @@ def preview_modal_dev(book: dict[str, pd.DataFrame], feature_cols: list[str]):
     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)
+            with t1: st.pyplot(make_index_tracks(df, FEATURES), use_container_width=True)
+            with t2: st.dataframe(stats_table(df, FEATURES), use_container_width=True)
 
 @dialog("Preview data")
-def preview_modal_val(book: dict[str, pd.DataFrame], feature_cols: list[str]):
+def preview_modal_single(book: dict[str, pd.DataFrame], feature_cols: list[str], names=("Validation","Validate","validation2","Val","val","Prediction","Pred")):
     if not book:
         st.info("No data loaded yet."); return
-    vname = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
+    vname = find_sheet(book, list(names)) 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
 # =========================
@@ -369,37 +379,25 @@ except Exception as e:
     st.error(f"Failed to load model: {model_path}\n{e}")
     st.stop()
 
-# Meta overrides / inference
+# 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
-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
+        FEATURES = meta.get("features", FEATURES)
+        TARGET = meta.get("target", TARGET)
+    except Exception:
+        pass
+
 
 # =========================
 # Session state
 # =========================
-if "app_step" not in st.session_state: st.session_state.app_step = "dev"  # start at Case Building after gate
+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)
+# persist dev file
 for k, v in {
     "dev_ready": False,
     "dev_file_loaded": False,
@@ -413,6 +411,7 @@ for k, v in {
 }.items():
     if k not in st.session_state: st.session_state[k] = v
 
+
 # =========================
 # Hero header
 # =========================
@@ -429,6 +428,33 @@ st.markdown(
     unsafe_allow_html=True,
 )
 
+
+# =========================
+# 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.subheader("Expected Input Features (in Order)")
+    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 Validation** to validate on a new dataset (with actual UCS, if available).  \n"
+        "4. Click **Proceed to Prediction** to generate predictions only (no actuals).  \n"
+        "5. Export results to Excel at any time."
+    )
+    if st.button("Start Showcase", type="primary"):
+        st.session_state.app_step = "dev"; st.rerun()
+
+
 # =========================
 # CASE BUILDING (Development)
 # =========================
@@ -463,46 +489,45 @@ 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:
+    # Sidebar actions (proceed buttons enabled always)
+    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)
+    if st.sidebar.button("Proceed to Validation ▶", use_container_width=True):
+        st.session_state.app_step = "val"; st.rerun()
+    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
+        st.session_state.app_step = "pred"; st.rerun()
+
+    # Title + helper
+    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.**")
 
-    # Navigation
-    st.sidebar.button("Proceed to Validation ▶", use_container_width=True,
-                      on_click=lambda: st.session_state.update(app_step="val"))
-    st.sidebar.button("Proceed to Prediction ▶", use_container_width=True,
-                      on_click=lambda: st.session_state.update(app_step="pred"))
-
-    # Helper
-    helper_top = st.container()
-    with helper_top:
-        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.**")
-
+    # open preview dialog if requested
     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
     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()
+            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()
@@ -527,39 +552,47 @@ if st.session_state.app_step == "dev":
             st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
 
             st.session_state.dev_ready = True
-            status.update(label="Done ✓", state="complete"); st.rerun()
+            status.update(label="Done ✓", state="complete")
+            st.rerun()
 
-    # Results (if available)
+    # Results
     if ("Train" in st.session_state.results) or ("Test" in st.session_state.results):
         tab1, tab2 = st.tabs(["Training", "Testing"])
+
+        def _result_block(df, metrics):
+            c1,c2,c3 = st.columns(3)
+            c1.metric("R²", f"{metrics['R2']:.4f}")
+            c2.metric("RMSE", f"{metrics['RMSE']:.4f}")
+            c3.metric("MAE", f"{metrics['MAE']:.4f}")
+
+            # center band with two equal columns
+            sp_l, main, sp_r = st.columns([1, 8, 1])
+            with main:
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.plotly_chart(
+                        cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
+                        use_container_width=False,
+                        config={"displayModeBar": False, "scrollZoom": True}
+                    )
+                with col2:
+                    st.plotly_chart(
+                        depth_or_index_track_interactive(df, include_actual=True),
+                        use_container_width=False,
+                        config={"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}")
-                # fixed-size plots side-by-side
-                left, right, _ = st.columns([1, 1, 3])
-                with left:
-                    st.plotly_chart(cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
-                                    use_container_width=False, config={"displayModeBar": False})
-                with right:
-                    st.plotly_chart(depth_or_index_track_interactive(df, include_actual=True),
-                                    use_container_width=False, config={"displayModeBar": False})
+                _result_block(st.session_state.results["Train"], st.session_state.results["metrics_train"])
         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([1, 1, 3])
-                with left:
-                    st.plotly_chart(cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
-                                    use_container_width=False, config={"displayModeBar": False})
-                with right:
-                    st.plotly_chart(depth_or_index_track_interactive(df, include_actual=True),
-                                    use_container_width=False, config={"displayModeBar": False})
+                _result_block(st.session_state.results["Test"], st.session_state.results["metrics_test"])
 
         st.markdown("---")
-        sheets = {}; rows = []
+        # export
+        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()}})
@@ -583,8 +616,9 @@ if st.session_state.app_step == "dev":
         except Exception as e:
             st.warning(str(e))
 
+
 # =========================
-# VALIDATION (with actuals)
+# VALIDATION (with actuals if present)
 # =========================
 if st.session_state.app_step == "val":
     st.sidebar.header("Validate the model")
@@ -595,18 +629,18 @@ if st.session_state.app_step == "val":
             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:
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=(validation_file is None)):
         _book = read_book_bytes(validation_file.getvalue())
-        preview_modal_val(_book, FEATURES)
+        preview_modal_single(_book, FEATURES)
 
     predict_btn = st.sidebar.button("Predict", type="primary", 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)
-    st.sidebar.button("Proceed to Prediction ▶", use_container_width=True,
-                      on_click=lambda: st.session_state.update(app_step="pred"))
+    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
+        st.session_state.app_step = "pred"; st.rerun()
+    if st.sidebar.button("⬅ Back to Case Building", use_container_width=True):
+        st.session_state.app_step = "dev"; st.rerun()
 
-    st.subheader("Validate the model")
-    st.write("Upload a dataset that includes actual UCS to evaluate model performance.")
+    st.subheader("Validation")
+    st.write("Upload a dataset to generate UCS predictions and evaluate performance on unseen data.")
 
     if predict_btn and validation_file is not None:
         with st.status("Predicting…", expanded=False) as status:
@@ -615,7 +649,8 @@ if st.session_state.app_step == "val":
             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 + [TARGET]): status.update(label="Missing required columns.", state="error"); st.stop()
+            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
@@ -629,11 +664,13 @@ if st.session_state.app_step == "val":
                     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 = {
-                "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 = 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),
@@ -645,49 +682,58 @@ if st.session_state.app_step == "val":
             status.update(label="Predictions ready ✓", state="complete")
 
     if "Validate" in st.session_state.results:
-        st.subheader("Validation Results")
-        sv = st.session_state.results["summary_val"]; oor_table = st.session_state.results.get("oor_table")
+        dfv = st.session_state.results["Validate"]
+        sv  = st.session_state.results["summary_val"]
+        oor_table = st.session_state.results.get("oor_table")
         metrics_val = st.session_state.results.get("metrics_val")
-        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}")
-
-        left, right, _ = st.columns([1, 1, 3])
-        with left:
-            st.plotly_chart(
-                cross_plot_interactive(st.session_state.results["Validate"][TARGET],
-                                       st.session_state.results["Validate"]["UCS_Pred"]),
-                use_container_width=False, config={"displayModeBar": False}
-            )
-        with right:
-            st.plotly_chart(
-                depth_or_index_track_interactive(st.session_state.results["Validate"],
-                                                 include_actual=True),
-                use_container_width=False, config={"displayModeBar": False}
-            )
 
         if sv["oor_pct"] > 0:
-            st.write("**★ Note:** Some validation inputs fall outside the training min–max ranges. Interpret predictions with caution.")
+            st.warning("Some validation inputs fall outside the **training min–max** ranges. Interpret predictions with caution.")
+
+        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}")
+
+        sp_l, main, sp_r = st.columns([1, 8, 1])
+        with main:
+            col1, col2 = st.columns(2)
+            with col1:
+                if TARGET in dfv.columns:
+                    st.plotly_chart(
+                        cross_plot_interactive(dfv[TARGET], dfv["UCS_Pred"]),
+                        use_container_width=False,
+                        config={"displayModeBar": False, "scrollZoom": True}
+                    )
+                else:
+                    st.info("Actual UCS values are not available in the validation data. Cross-plot cannot be generated.")
+            with col2:
+                st.plotly_chart(
+                    depth_or_index_track_interactive(dfv, include_actual=(TARGET in dfv.columns)),
+                    use_container_width=False,
+                    config={"displayModeBar": False, "scrollZoom": True}
+                )
 
         if oor_table is not None:
             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
+        # export
         try:
             buf = io.BytesIO()
             with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                for name, frame in sheets.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)
+                dfv.to_excel(xw, sheet_name="Validate_with_pred", index=False)
+                if metrics_val is not None:
+                    pd.DataFrame([{"Split":"Validate", **{k: round(v,6) for k,v in metrics_val.items()}}]).to_excel(
+                        xw, sheet_name="Summary", index=False
+                    )
             st.download_button(
                 "Export Validation Results to Excel",
                 data=buf.getvalue(),
@@ -697,89 +743,111 @@ if st.session_state.app_step == "val":
         except Exception as e:
             st.warning(str(e))
 
+
 # =========================
 # PREDICTION (no actuals)
 # =========================
 if st.session_state.app_step == "pred":
-    st.sidebar.header("Prediction (New data)")
-    pred_file = st.sidebar.file_uploader("Upload Prediction Excel (no UCS column)", type=["xlsx","xls"], key="pred_upload")
+    st.sidebar.header("Prediction")
+    pred_file = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"], key="pred_upload")
     if pred_file is not None:
         _book_tmp = read_book_bytes(pred_file.getvalue())
         if _book_tmp:
             first_df = next(iter(_book_tmp.values()))
             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=(pred_file is None))
-    if preview_pred_btn and pred_file is not None:
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=(pred_file is None)):
         _book = read_book_bytes(pred_file.getvalue())
-        preview_modal_val(_book, FEATURES)  # same preview (tracks & summary)
+        preview_modal_single(_book, FEATURES, names=("Prediction","Pred","Sheet1","Data"))
 
-    do_pred_btn = st.sidebar.button("Predict", type="primary", 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)
-    st.sidebar.button("⬅ Back to Validation", on_click=lambda: st.session_state.update(app_step="val"), use_container_width=True)
+    pred_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
+    if st.sidebar.button("⬅ Back to Validation", use_container_width=True):
+        st.session_state.app_step = "val"; st.rerun()
 
     st.subheader("Prediction")
-    st.write("Upload a new dataset (without UCS) and generate UCS predictions.")
+    st.write("Upload a dataset to generate UCS predictions (no actuals required).")
 
-    if do_pred_btn and pred_file is not None:
+    if pred_btn and pred_file is not None:
         with st.status("Predicting…", expanded=False) as status:
             pbook = read_book_bytes(pred_file.getvalue())
             if not pbook: status.update(label="Could not read the Prediction Excel.", state="error"); st.stop()
             status.update(label="Workbook read ✓")
-            vname = list(pbook.keys())[0]
-            df = pbook[vname].copy()
-            if not ensure_cols(df, 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["UCS_Pred"] = model.predict(df[FEATURES])
-            st.session_state.results["PredictOnly"] = df
+            dfp["UCS_Pred"] = model.predict(dfp[FEATURES])
+            st.session_state.results["PredictOnly"] = dfp
 
-            ranges = st.session_state.train_ranges; oor_pct = 0.0
+            ranges = st.session_state.train_ranges
+            oor_pct = None
             if ranges:
-                any_viol = pd.DataFrame({f: (df[f] < ranges[f][0]) | (df[f] > ranges[f][1]) for f in FEATURES}).any(axis=1)
+                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)
 
-            st.session_state.results["summary_predonly"] = {
-                "n_points": len(df),
-                "pred_min": float(df["UCS_Pred"].min()),
-                "pred_max": float(df["UCS_Pred"].max()),
-                "pred_mean": float(df["UCS_Pred"].mean()),
-                "pred_std": float(df["UCS_Pred"].std(ddof=0)),
-                "oor_pct": oor_pct
+            st.session_state.results["summary_pred"] = {
+                "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 if oor_pct is not None else None
             }
             status.update(label="Predictions ready ✓", state="complete")
 
     if "PredictOnly" in st.session_state.results:
-        st.success("Predictions ready ✓")
-        s = st.session_state.results["summary_predonly"]
-        # Summary table left, track right
-        left, right, _ = st.columns([1, 1, 3])
-        with left:
-            st.table(pd.DataFrame({
-                "Metric": ["# points", "Pred min", "Pred max", "Pred mean", "Pred std", "OOR %"],
-                "Value":  [s["n_points"], s["pred_min"], s["pred_max"], s["pred_mean"], s["pred_std"], f"{s['oor_pct']:.1f}%"]
-            }))
-            st.caption("★ OOR%: fraction of rows where any input lies outside the training min–max range.")
-        with right:
-            st.plotly_chart(
-                depth_or_index_track_interactive(st.session_state.results["PredictOnly"], include_actual=False),
-                use_container_width=False, config={"displayModeBar": False}
-            )
+        dfp = st.session_state.results["PredictOnly"]
+        sp = st.session_state.results["summary_pred"]
+
+        # summary table (left) + track (right)
+        sp_l, main, sp_r = st.columns([1, 8, 1])
+        with main:
+            col1, col2 = st.columns([1, 1])
+            with col1:
+                table = pd.DataFrame({
+                    "Metric": ["# points", "Pred min", "Pred max", "Pred mean", "Pred std", "OOR %"],
+                    "Value": [
+                        sp["n_points"],
+                        f"{sp['pred_min']:.2f}",
+                        f"{sp['pred_max']:.2f}",
+                        f"{sp['pred_mean']:.2f}",
+                        f"{sp['pred_std']:.2f}",
+                        (f"{sp['oor_pct']:.1f}%" if sp["oor_pct"] is not None else "N/A")
+                    ]
+                })
+                st.write("✅ Predictions ready ✓")
+                st.dataframe(table, use_container_width=True)
+                st.markdown(
+                    "<div class='help-foot'>* OOR% = percentage of rows with any input feature outside the "
+                    "training min–max range (computed when Case Building has been run).</div>",
+                    unsafe_allow_html=True
+                )
+            with col2:
+                st.plotly_chart(
+                    depth_or_index_track_interactive(dfp, include_actual=False),
+                    use_container_width=False,
+                    config={"displayModeBar": False, "scrollZoom": True}
+                )
 
         st.markdown("---")
+        # export
         try:
             buf = io.BytesIO()
             with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                st.session_state.results["PredictOnly"].to_excel(xw, sheet_name="Predictions", index=False)
-                pd.DataFrame([s]).to_excel(xw, sheet_name="Summary", index=False)
+                dfp.to_excel(xw, sheet_name="Prediction_with_pred", index=False)
+                pd.DataFrame([sp]).to_excel(xw, sheet_name="Summary", index=False)
             st.download_button(
-                "Export Predictions to Excel",
+                "Export Prediction Results to Excel",
                 data=buf.getvalue(),
-                file_name="UCS_Predictions.xlsx",
+                file_name="UCS_Prediction_Results.xlsx",
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
             )
         except Exception as e:
             st.warning(str(e))
 
+
 # =========================
 # Footer
 # =========================