Update app.py

app.py

@@ -26,33 +26,35 @@ MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
 # =========================
-# Page / Theme (must be first)
+# Page / Theme
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
 
-# ---------- utilities used by the gate ----------
+# ---------- inline logo (used by password gate + header) ----------
 def inline_logo(path="logo.png") -> str:
     try:
         p = Path(path)
-        if p.exists():
-            return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
+        if not p.exists(): return ""
+        return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
     except Exception:
-        pass
-    return ""
+        return ""
 
-# ---------- Password gate (define BEFORE calling) ----------
+# =========================
+# Password (brand-gated)
+# =========================
 def add_password_gate() -> bool:
     """
     Shows a branded access screen until the correct password is entered.
-    Set the password through Settings → Secrets as APP_PASSWORD (or an env var).
+    Requires APP_PASSWORD in Secrets (or environment).
     """
-    # 1) Read required password
+    # 1) Read password
+    required = ""
     try:
         required = st.secrets.get("APP_PASSWORD", "")
     except Exception:
         required = os.environ.get("APP_PASSWORD", "")
 
-    # 2) If not configured, block with an admin hint
+    # 2) If not configured, BLOCK (admin instruction)
     if not required:
         st.markdown(
             f"""
@@ -77,7 +79,7 @@ def add_password_gate() -> bool:
     if st.session_state.get("auth_ok", False):
         return True
 
-    # 4) Prompt
+    # 4) Branded prompt
     st.markdown(
         f"""
         <div style="display:flex;align-items:center;gap:14px;margin:8px 0 6px 0;">
@@ -105,10 +107,10 @@ def add_password_gate() -> bool:
                 st.error("Incorrect key. Please try again.")
     st.stop()
 
-# 🔒 Enforce gate BEFORE any UI is rendered
+# 🔒 Gate the app
 add_password_gate()
 
-# After the gate: global CSS/UI may render
+# … CSS …
 st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
 st.markdown(
     """
@@ -129,7 +131,7 @@ st.markdown(
 )
 
 # =========================
-# Helpers / caching
+# Helpers
 # =========================
 try:
     dialog = st.dialog
@@ -177,9 +179,8 @@ def find_sheet(book, names):
         if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
-# ---------- Interactive plotting ----------
+# ---------- Interactive plotting (full outline, bold axis titles) ----------
 def cross_plot_interactive(actual, pred, size=(3.9, 3.9)):
-    """Interactive cross-plot: blue points, dashed 1:1, equal axes, no title, numeric ticks, full box outline."""
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
     lo = float(np.nanmin([a.min(), p.min()]))
@@ -219,11 +220,11 @@ def cross_plot_interactive(actual, pred, size=(3.9, 3.9)):
         tickformat=",.0f", scaleanchor="x", scaleratio=1,
         automargin=True
     )
-    fig.update_layout(width=int(size[0]*100), height=int(size[1]*100))
+    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):
-    """Interactive UCS track: blue solid pred, yellow dotted actual, legend inside; x on top; full box outline."""
     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
@@ -244,6 +245,7 @@ def depth_or_index_track_interactive(df, title=None, include_actual=True):
             name="UCS (actual)",
             hovertemplate="UCS (actual): %{x:.2f}<br>"+y_label+": %{y}<extra></extra>"
         ))
+
     fig.update_layout(
         paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
         margin=dict(l=60, r=10, t=10, b=36),
@@ -332,29 +334,27 @@ def preview_modal_val(book: dict[str, pd.DataFrame], feature_cols: list[str]):
 # =========================
 # Model presence
 # =========================
-def _download_model(url: str, dest: Path) -> bool:
+MODEL_URL = _get_model_url()
+
+def ensure_model_present() -> Path:
+    for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
+        if p.exists() and p.stat().st_size > 0:
+            return p
+    if not MODEL_URL:
+        return None
     try:
         import requests
-        dest.parent.mkdir(parents=True, exist_ok=True)
+        DEFAULT_MODEL.parent.mkdir(parents=True, exist_ok=True)
         with st.status("Downloading model…", expanded=False):
-            with requests.get(url, stream=True, timeout=30) as r:
+            with requests.get(MODEL_URL, stream=True, timeout=30) as r:
                 r.raise_for_status()
-                with open(dest, "wb") as f:
-                    for chunk in r.iter_content(chunk_size=1 << 20):
+                with open(DEFAULT_MODEL, "wb") as f:
+                    for chunk in r.iter_content(chunk_size=1<<20):
                         if chunk: f.write(chunk)
-        return True
+        return DEFAULT_MODEL
     except Exception as e:
         st.error(f"Failed to download model from MODEL_URL: {e}")
-        return False
-
-MODEL_URL = _get_model_url()
-def ensure_model_present() -> Path | None:
-    for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
-        if p.exists() and p.stat().st_size > 0:
-            return p
-    if MODEL_URL and _download_model(MODEL_URL, DEFAULT_MODEL):
-        return DEFAULT_MODEL
-    return None
+        return None
 
 model_path = ensure_model_present()
 if not model_path:
@@ -380,15 +380,13 @@ else:
         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
+        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
+        except Exception: pass
         return None
     infer = infer_features_from_model(model)
     if infer: FEATURES = infer
@@ -411,11 +409,19 @@ for k, v in {
     "dev_file_name": "",
     "dev_file_rows": 0,
     "dev_file_cols": 0,
+    # validation (was predict)
+    "val_file_bytes": b"",
+    "val_file_loaded": False,
+    "val_preview_request": False,
+    # prediction (new)
+    "pred_file_bytes": b"",
+    "pred_file_loaded": False,
+    "pred_preview_request": False,
 }.items():
     if k not in st.session_state: st.session_state[k] = v
 
 # =========================
-# Hero header (after gate)
+# Hero header
 # =========================
 st.markdown(
     f"""
@@ -435,7 +441,9 @@ st.markdown(
 # =========================
 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"
@@ -448,17 +456,18 @@ if st.session_state.app_step == "intro":
     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."
+        "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."
     )
     if st.button("Start Showcase", type="primary", key="start_showcase"):
         st.session_state.app_step = "dev"; st.rerun()
 
 # =========================
-# Case Building
+# 1) CASE BUILDING (Development)
 # =========================
 if st.session_state.app_step == "dev":
-    st.sidebar.header("Data for Case Building")
+    st.sidebar.header("Case Building (Development)")
     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")
 
@@ -473,7 +482,6 @@ if st.session_state.app_step == "dev":
             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()))
@@ -483,31 +491,28 @@ if st.session_state.app_step == "dev":
                 st.session_state.dev_previewed = False
                 st.session_state.dev_ready = False
 
-    # Sidebar caption
     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"
         )
 
-    # 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:
+    # Always enabled so users can jump ahead
+    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:
+        st.session_state.app_step = "validate"; st.rerun()
+    if proceed_pred:
         st.session_state.app_step = "predict"; st.rerun()
 
-    # ----- ALWAYS-ON TOP: Title + helper -----
-    helper_top = st.container()
-    with helper_top:
+    # Helper (always at top)
+    with st.container():
         st.subheader("Case Building")
         if st.session_state.dev_ready:
             st.success("Case has been built and results are displayed below.")
@@ -518,14 +523,12 @@ if st.session_state.app_step == "dev":
         else:
             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)
@@ -561,7 +564,6 @@ if st.session_state.app_step == "dev":
             st.session_state.dev_ready = True
             status.update(label="Done ✓", state="complete"); st.rerun()
 
-    # Results (if available)
     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:
@@ -623,31 +625,46 @@ if st.session_state.app_step == "dev":
             st.warning(str(e))
 
 # =========================
-# PREDICTION (Validation)
+# 2) VALIDATE THE MODEL (was predict)
 # =========================
-if st.session_state.app_step == "predict":
-    st.sidebar.header("Prediction (Validation)")
+if st.session_state.app_step == "validate":
+    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:
-        _book_tmp = read_book_bytes(validation_file.getvalue())
+        st.session_state.val_file_bytes = validation_file.getvalue()
+        _book_tmp = read_book_bytes(st.session_state.val_file_bytes)
         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=(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)
+    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
 
-    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)
+    predict_btn = st.sidebar.button("Run Validation", type="primary", use_container_width=True)
 
-    st.subheader("Prediction")
-    st.write("Upload a new dataset to generate UCS predictions and evaluate performance on unseen data.")
+    # Always enabled
+    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()
 
-    if predict_btn and validation_file is not None:
-        with st.status("Predicting…", expanded=False) as status:
-            vbook = read_book_bytes(validation_file.getvalue())
+    # Helper
+    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.")
+
+    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)
+
+    # Run validation
+    if predict_btn and st.session_state.val_file_bytes:
+        with st.status("Validating…", expanded=False) as status:
+            vbook = read_book_bytes(st.session_state.val_file_bytes)
             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]
@@ -681,16 +698,15 @@ if st.session_state.app_step == "predict":
                 "oor_pct": oor_pct
             }
             st.session_state.results["oor_table"] = oor_table
-            status.update(label="Predictions ready ✓", state="complete")
+            status.update(label="Validation ready ✓", state="complete")
 
+    # Display
     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")
 
         if sv["oor_pct"] > 0:
             st.warning("Some validation inputs fall outside the **training min–max** ranges. Interpret predictions with caution.")
 
-        # Prefer dev-like metrics when actual UCS exists
         metrics_val = st.session_state.results.get("metrics_val")
         if metrics_val is not None:
             c1, c2, c3 = st.columns(3)
@@ -698,11 +714,10 @@ if st.session_state.app_step == "predict":
             c2.metric("RMSE", f"{metrics_val['RMSE']:.4f}")
             c3.metric("MAE",  f"{metrics_val['MAE']:.4f}")
         else:
-            c1, c2, c3, c4 = st.columns(4)
-            c1.metric("points", f"{sv['n_points']}")
+            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}")
-            c4.metric("OOR %",   f"{sv['oor_pct']:.1f}%")
 
         left, right = st.columns([0.9, 0.55])
         with left:
@@ -754,6 +769,124 @@ if st.session_state.app_step == "predict":
         except Exception as e:
             st.warning(str(e))
 
+# =========================
+# 3) PREDICTION (production scoring, 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")
+
+    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)
+        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
+
+    predict_btn = 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)
+
+    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
+        # Reuse the same previewer (no special sheet naming required)
+        preview_modal_val(_book, FEATURES)
+
+    # Run prediction
+    if predict_btn and st.session_state.pred_file_bytes:
+        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()
+            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()
+            status.update(label="Columns validated ✓")
+            df_pred["UCS_Pred"] = model.predict(df_pred[FEATURES])
+            st.session_state.results["Prediction"] = df_pred
+
+            # OOR vs training ranges if available
+            ranges = st.session_state.train_ranges; oor_table = None; oor_pct = 0.0
+            if ranges:
+                viol = {f: (df_pred[f] < ranges[f][0]) | (df_pred[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)),
+                "oor_pct": oor_pct
+            }
+            st.session_state.results["oor_table_pred"] = oor_table
+            status.update(label="Predictions ready ✓", state="complete")
+
+    # Display prediction results (no cross-plot)
+    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.")
+
+        # Two columns: table (left), track (right)
+        left, right = st.columns([0.6, 0.9])
+        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)
+        with right:
+            st.plotly_chart(
+                depth_or_index_track_interactive(
+                    st.session_state.results["Prediction"], title=None, include_actual=False
+                ),
+                use_container_width=True, config={"displayModeBar": False}
+            )
+
+        # OOR table if any
+        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)
+
+        st.markdown("---")
+        # Export predictions + summary
+        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)
+                pd.DataFrame([sv]).to_excel(xw, sheet_name="Summary", index=False)
+            st.download_button(
+                "Export Prediction Results to Excel",
+                data=buf.getvalue(),
+                file_name="UCS_Prediction_Results.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
+        except Exception as e:
+            st.warning(str(e))
+
 # =========================
 # Footer
 # =========================
@@ -766,4 +899,4 @@ st.markdown(
     </div>
     """,
     unsafe_allow_html=True
-)
+)