Update app.py

app.py

@@ -1,5 +1,5 @@
 # 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
@@ -22,14 +22,13 @@ 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"}
 
 # ---- Plot sizing controls (edit here) ----
 CROSS_W = 400; CROSS_H = 400      # square cross-plot
 TRACK_W = 400; TRACK_H = 950      # log-strip style (tall, slightly wider)
 FONT_SZ = 13
-PLOT_COLS = [14,1, 10]           # 3-column band: left • spacer • right
+PLOT_COLS = [14, 1, 10]           # 3-column band: left • spacer • right
 
 # =========================
 # Page / CSS
@@ -49,14 +48,6 @@ st.markdown(
       .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; }
-
-      /* sticky helper notice */
-      .helper-sticky { position: sticky; top: 64px; z-index: 50; }
-      .helper-sticky .box {
-        border-radius: 8px; padding: 12px 14px; margin: 6px 0 10px 0; font-size: 0.98rem;
-      }
-      .helper-sticky .info    { background:#eaf2ff; border:1px solid #c9defa; color:#0b4aa2; }
-      .helper-sticky .success { background:#eaf7ea; border:1px solid #c7e8c8; color:#1b6e22; }
     </style>
     """,
     unsafe_allow_html=True
@@ -154,21 +145,20 @@ def parse_excel(data_bytes: bytes):
     return {sh: xl.parse(sh) for sh in xl.sheet_names}
 
 def read_book_bytes(b: bytes): return parse_excel(b) if b else {}
-
-def ensure_cols(df, cols):
-    miss = [c for c in cols if c not in df.columns]
-    if miss:
-        st.error(f"Missing columns: {miss}")
-        return False
-    return True
-
+def ensure_cols(df, cols): return not [c for c in cols if c not in df.columns] or False
 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
 
-# ---------- Plot builders (fixed pixel sizes; full outline; crisp) ----------
+def _nice_tick0(xmin: float, step: int = 100) -> float:
+    """Round xmin down to a sensible multiple so the first tick sits at the left edge."""
+    if not np.isfinite(xmin):
+        return xmin
+    return step * math.floor(xmin / step)
+
+# ---------- Plot builders ----------
 def cross_plot(actual, pred):
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
@@ -191,25 +181,41 @@ def cross_plot(actual, pred):
     ))
     fig.update_layout(
         width=CROSS_W, height=CROSS_H, paper_bgcolor="#fff", plot_bgcolor="#fff",
-        margin=dict(l=64, r=18, t=8, b=48), hovermode="closest",
+        margin=dict(l=64, r=18, t=10, b=48), hovermode="closest",
         font=dict(size=FONT_SZ)
     )
-    fig.update_xaxes(title_text="<b>Actual UCS</b>", range=[x0, x1],
+    fig.update_xaxes(title_text="<b>Actual UCS (psi)</b>", range=[x0, x1],
                      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="<b>Predicted UCS</b>", range=[x0, x1],
+                     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 (psi)</b>", range=[x0, x1],
                      ticks="outside", tickformat=",.0f",
-                     showline=True, linewidth=1.2, linecolor="#444", mirror=True, showgrid=True, gridcolor="rgba(0,0,0,0.12)",
+                     showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+                     showgrid=True, gridcolor="rgba(0,0,0,0.12)",
                      scaleanchor="x", scaleratio=1, automargin=True)
     return fig
 
 def track_plot(df, include_actual=True):
     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]; ylab = depth_col; autorange = "reversed"
+        y = pd.Series(df[depth_col]).astype(float)
+        ylab = depth_col
+        y_min, y_max = float(y.min()), float(y.max())
+        y_range = [y_max, y_min]   # reversed for log profile style
     else:
-        y = np.arange(1, len(df) + 1); ylab = "Point Index"; autorange = "reversed"
+        y = pd.Series(np.arange(1, len(df) + 1))
+        ylab = "Point Index"
+        y_min, y_max = float(y.min()), float(y.max())
+        y_range = [y_max, y_min]
+
+    # X (UCS) range & ticks
+    x_series = pd.Series(df.get("UCS_Pred", pd.Series(dtype=float))).astype(float)
+    if include_actual and TARGET in df.columns:
+        x_series = pd.concat([x_series, pd.Series(df[TARGET]).astype(float)], ignore_index=True)
+    x_lo, x_hi = float(x_series.min()), float(x_series.max())
+    x_pad = 0.03 * (x_hi - x_lo if x_hi > x_lo else 1.0)
+    xmin, xmax = x_lo - x_pad, x_hi + x_pad
+    tick0 = _nice_tick0(xmin, step=100)  # sensible first tick at left border
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -228,22 +234,27 @@ def track_plot(df, include_actual=True):
 
     fig.update_layout(
         width=TRACK_W, height=TRACK_H, paper_bgcolor="#fff", plot_bgcolor="#fff",
-        margin=dict(l=72, r=18, t=30, b=48), hovermode="closest",
+        margin=dict(l=72, r=18, t=36, b=48), hovermode="closest",
         font=dict(size=FONT_SZ),
         legend=dict(
             x=0.98, y=0.05, xanchor="right", yanchor="bottom",
-            bgcolor="rgba(255,255,255,0.78)", bordercolor="#ccc", borderwidth=1
+            bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1
         ),
         legend_title_text=""
     )
-    fig.update_xaxes(title_text="<b>UCS</b>", side="top",
-                     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>{ylab}</b>", autorange=autorange,
-                     ticks="outside",
-                     showline=True, linewidth=1.2, linecolor="#444", mirror=True, showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-                     automargin=True)
+    fig.update_xaxes(
+        title_text="<b>UCS (psi)</b>", side="top", range=[xmin, xmax],
+        ticks="outside", tickformat=",.0f",
+        tickmode="auto", tick0=tick0,
+        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+    )
+    fig.update_yaxes(
+        title_text=f"<b>{ylab}</b>", range=y_range,
+        ticks="outside",
+        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+    )
     return fig
 
 # ---------- Preview modal (matplotlib) ----------
@@ -251,7 +262,10 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
     if n == 0:
-        fig, ax = plt.subplots(figsize=(4, 2)); ax.text(0.5,0.5,"No selected columns",ha="center",va="center"); ax.axis("off"); return fig
+        fig, ax = plt.subplots(figsize=(4, 2))
+        ax.text(0.5,0.5,"No selected columns",ha="center",va="center")
+        ax.axis("off")
+        return fig
     fig, axes = plt.subplots(1, n, figsize=(2.2*n, 7.0), sharey=True, dpi=100)
     if n == 1: axes = [axes]
     idx = np.arange(1, len(df) + 1)
@@ -263,6 +277,17 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
     axes[0].set_ylabel("Point Index")
     return fig
 
+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
+
 @dialog("Preview data")
 def preview_modal(book: dict[str, pd.DataFrame]):
     if not book:
@@ -308,7 +333,6 @@ except Exception as e:
     st.error(f"Failed to load model: {e}")
     st.stop()
 
-# Try to pull features from model if provided
 meta_path = MODELS_DIR / "meta.json"
 if meta_path.exists():
     try:
@@ -323,20 +347,10 @@ if meta_path.exists():
 st.session_state.setdefault("app_step", "intro")
 st.session_state.setdefault("results", {})
 st.session_state.setdefault("train_ranges", None)
-
-# dev file state
-for k, v in {
-    "dev_file_name":"", "dev_file_bytes":b"", "dev_file_loaded":False,
-    "dev_preview":False
-}.items():
-    st.session_state.setdefault(k, v)
-
-# helper notice anchor (sticky)
-def make_notice():
-    anchor = st.empty()
-    def info(msg_html):    anchor.markdown(f"<div class='helper-sticky'><div class='box info'>{msg_html}</div></div>", unsafe_allow_html=True)
-    def success(msg_html): anchor.markdown(f"<div class='helper-sticky'><div class='box success'>{msg_html}</div></div>", unsafe_allow_html=True)
-    return info, success
+st.session_state.setdefault("dev_file_name","")
+st.session_state.setdefault("dev_file_bytes",b"")
+st.session_state.setdefault("dev_file_loaded",False)
+st.session_state.setdefault("dev_preview",False)
 
 # =========================
 # Hero
@@ -354,9 +368,6 @@ st.markdown(
     unsafe_allow_html=True,
 )
 
-# reuse plot config
-PLOT_CFG = {"displayModeBar": False, "scrollZoom": True}
-
 # =========================
 # INTRO
 # =========================
@@ -394,19 +405,20 @@ if st.session_state.app_step == "dev":
         st.session_state.dev_preview = True
 
     run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
+    # always available nav
     if st.sidebar.button("Proceed to Validation ▶", use_container_width=True): st.session_state.app_step="validate"; st.rerun()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
-    info, success = make_notice()
-    st.subheader("Case Building (Development)")
-    if "Train" in st.session_state.results or "Test" in st.session_state.results:
-        success("Case has been built and results are displayed below.")
-    elif st.session_state.dev_file_loaded and st.session_state.dev_preview:
-        info("Previewed ✓ — now click <b>Run Model</b>.")
-    elif st.session_state.dev_file_loaded:
-        info("📄 <b>Preview uploaded data</b> using the sidebar button, then click <b>Run Model</b>.")
-    else:
-        info("<b>Upload your data</b> to build a case, then run the model to review development performance.")
+    # ---- Pinned helper at the very top of the page ----
+    helper_top = st.container()
+    with helper_top:
+        st.subheader("Case Building (Development)")
+        if st.session_state.dev_file_loaded and st.session_state.dev_preview:
+            st.info("Previewed ✓ — now click **Run Model**.")
+        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.**")
 
     if run and st.session_state.dev_file_bytes:
         book = read_book_bytes(st.session_state.dev_file_bytes)
@@ -415,7 +427,8 @@ if st.session_state.app_step == "dev":
         if sh_train is None or sh_test is None:
             st.error("Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets."); st.stop()
         tr = book[sh_train].copy(); te = book[sh_test].copy()
-        if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])): st.stop()
+        if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])):
+            st.error("Missing required columns."); st.stop()
         tr["UCS_Pred"] = model.predict(tr[FEATURES])
         te["UCS_Pred"] = model.predict(te[FEATURES])
 
@@ -425,28 +438,31 @@ if st.session_state.app_step == "dev":
 
         tr_min = tr[FEATURES].min().to_dict(); tr_max = tr[FEATURES].max().to_dict()
         st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
-        st.rerun()
+        st.success("Case has been built and results are displayed below.")
+
+    def _dev_block(df, m):
+        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, spacer, right = st.columns(PLOT_COLS)
+        with left:
+            st.plotly_chart(
+                cross_plot(df[TARGET], df["UCS_Pred"]),
+                use_container_width=False,
+                config={"displayModeBar": False, "scrollZoom": True}
+            )
+        with right:
+            st.plotly_chart(
+                track_plot(df, include_actual=True),
+                use_container_width=False,
+                config={"displayModeBar": False, "scrollZoom": True}
+            )
 
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
-
-        def dev_block(df, m):
-            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, mid, right = st.columns(PLOT_COLS, gap="small")
-            with left:
-                st.plotly_chart(cross_plot(df[TARGET], df["UCS_Pred"]),
-                                use_container_width=False, config=PLOT_CFG)
-            with mid:
-                st.write("")  # spacer
-            with right:
-                st.plotly_chart(track_plot(df, include_actual=True),
-                                use_container_width=False, config=PLOT_CFG)
-
         if "Train" in st.session_state.results:
-            with tab1: dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
+            with tab1: _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
         if "Test" in st.session_state.results:
-            with tab2: dev_block(st.session_state.results["Test"],  st.session_state.results["m_test"])
+            with tab2: _dev_block(st.session_state.results["Test"],  st.session_state.results["m_test"])
 
 # =========================
 # VALIDATION (with actual UCS)
@@ -465,15 +481,14 @@ if st.session_state.app_step == "validate":
     if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
-    info, success = make_notice()
     st.subheader("Validate the Model")
-    info("Upload a dataset with the same <b>features</b> and <b>UCS</b> to evaluate performance.")
+    st.write("Upload a dataset with the same **features** and **UCS** to evaluate performance.")
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue())
         name = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
         df = book[name].copy()
-        if not ensure_cols(df, FEATURES+[TARGET]): st.stop()
+        if not ensure_cols(df, FEATURES+[TARGET]): st.error("Missing required columns."); st.stop()
         df["UCS_Pred"] = model.predict(df[FEATURES])
         st.session_state.results["Validate"]=df
 
@@ -487,25 +502,26 @@ if st.session_state.app_step == "validate":
         st.session_state.results["m_val"]={"R2":r2_score(df[TARGET],df["UCS_Pred"]), "RMSE":rmse(df[TARGET],df["UCS_Pred"]), "MAE":mean_absolute_error(df[TARGET],df["UCS_Pred"])}
         st.session_state.results["sv_val"]={"n":len(df),"pred_min":float(df["UCS_Pred"].min()),"pred_max":float(df["UCS_Pred"].max()),"oor":oor_pct}
         st.session_state.results["oor_tbl"]=tbl
-        st.rerun()
 
     if "Validate" in st.session_state.results:
         m = st.session_state.results["m_val"]; sv = st.session_state.results["sv_val"]
         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, mid, right = st.columns(PLOT_COLS, gap="small")
+        left, spacer, right = st.columns(PLOT_COLS)
         with left:
-            st.plotly_chart(cross_plot(st.session_state.results["Validate"][TARGET],
-                                       st.session_state.results["Validate"]["UCS_Pred"]),
-                            use_container_width=False, config=PLOT_CFG)
-        with mid:
-            st.write("")
+            st.plotly_chart(
+                cross_plot(st.session_state.results["Validate"][TARGET],
+                           st.session_state.results["Validate"]["UCS_Pred"]),
+                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
+            )
         with right:
-            st.plotly_chart(track_plot(st.session_state.results["Validate"], include_actual=True),
-                            use_container_width=False, config=PLOT_CFG)
+            st.plotly_chart(
+                track_plot(st.session_state.results["Validate"], include_actual=True),
+                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
+            )
 
-        if sv["oor"] > 0: st.warning("Some inputs fall outside <b>training min–max</b> ranges.", icon="⚠️")
+        if sv["oor"] > 0: st.warning("Some inputs fall outside **training min–max** ranges.")
         if st.session_state.results["oor_tbl"] is not None:
             st.write("*Out-of-range rows (vs. Training min–max):*")
             st.dataframe(st.session_state.results["oor_tbl"], use_container_width=True)
@@ -526,14 +542,13 @@ if st.session_state.app_step == "predict":
     go_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
     if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
 
-    info, _success = make_notice()
     st.subheader("Prediction")
-    info("Upload a dataset with the feature columns (no <b>UCS</b>).")
+    st.write("Upload a dataset with the feature columns (no **UCS**).")
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
         df = book[name].copy()
-        if not ensure_cols(df, FEATURES): st.stop()
+        if not ensure_cols(df, FEATURES): st.error("Missing required columns."); st.stop()
         df["UCS_Pred"] = model.predict(df[FEATURES])
         st.session_state.results["PredictOnly"]=df
 
@@ -549,12 +564,11 @@ if st.session_state.app_step == "predict":
             "pred_std":float(df["UCS_Pred"].std(ddof=0)),
             "oor":oor_pct
         }
-        st.rerun()
 
     if "PredictOnly" in st.session_state.results:
         df = st.session_state.results["PredictOnly"]; sv = st.session_state.results["sv_pred"]
 
-        left, mid, right = st.columns(PLOT_COLS, gap="small")
+        left, spacer, right = st.columns(PLOT_COLS)
         with left:
             table = pd.DataFrame({
                 "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
@@ -563,11 +577,11 @@ if st.session_state.app_step == "predict":
             st.success("Predictions ready ✓")
             st.dataframe(table, use_container_width=True, hide_index=True)
             st.caption("**★ OOR** = % of rows whose input features fall outside the training min–max range.")
-        with mid:
-            st.write("")
         with right:
-            st.plotly_chart(track_plot(df, include_actual=False),
-                            use_container_width=False, config=PLOT_CFG)
+            st.plotly_chart(
+                track_plot(df, include_actual=False),
+                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
+            )
 
 # =========================
 # Footer