Update app.py

app.py

@@ -36,25 +36,15 @@ BOLD_FONT = "Arial Black, Arial, sans-serif"  # used for bold axis titles & tick
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
 
-# This is the new CSS block with the added h1 color rule
+# This is the new CSS block for the sticky header and message box
 st.markdown("""
 <style>
-/* Add a light gray background to the main app container */
-.stApp {
-    background-color: #f0f2f6;
-}
-
-/* Change the color of the main page title (h1) to light blue */
-h1 {
-    color: #add8e6;
-}
-
 /* CSS to make the header sticky */
 .fixed-header-container {
     position: sticky;
     top: 0;
     z-index: 1000;
-    background-color: #f0f2f6; /* Ensure sticky header background matches app background */
+    background-color: #f0f2f6; /* Adjust to match your app's background color */
     padding: 10px 0;
     box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
 }
@@ -443,6 +433,11 @@ st.sidebar.markdown(f"""
     """, unsafe_allow_html=True
 )
 
+# =========================
+# Reusable Sticky Header Function
+# This function is now removed, replaced by the fixed-header-container
+# =========================
+
 # =========================
 # The main sticky container is defined here, before the app logic
 # This ensures it's rendered at the top of the page regardless of state.
@@ -476,9 +471,7 @@ with st.container():
 # =========================
 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("How It Works")
     st.markdown(
         "1) **Upload your data to build the case and preview the performance of our model.** \n"
@@ -486,8 +479,7 @@ if st.session_state.app_step == "intro":
         "3) **Proceed to Validation** (with actual UCS) or **Proceed to Prediction** (no UCS)."
     )
     if st.button("Start Showcase", type="primary"):
-        st.session_state.app_step = "dev"
-        st.rerun()
+        st.session_state.app_step = "dev"; st.rerun()
 
 # =========================
 # CASE BUILDING
@@ -504,70 +496,47 @@ if st.session_state.app_step == "dev":
         tmp = read_book_bytes(st.session_state.dev_file_bytes)
         if tmp:
             df0 = next(iter(tmp.values()))
-            st.sidebar.caption(
-                f"**Data loaded:** {st.session_state.dev_file_name} • {df0.shape[0]} rows × {df0.shape[1]} cols"
-            )
+            st.sidebar.caption(f"**Data loaded:** {st.session_state.dev_file_name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
 
-    if st.sidebar.button(
-        "Preview data",
-        use_container_width=True,
-        disabled=not st.session_state.dev_file_loaded
-    ):
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded):
         preview_modal(read_book_bytes(st.session_state.dev_file_bytes))
         st.session_state.dev_preview = True
 
     run = 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 = "validate"
-        st.rerun()
-    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
-        st.session_state.app_step = "predict"
-        st.rerun()
+    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()
 
     if run and st.session_state.dev_file_bytes:
         book = read_book_bytes(st.session_state.dev_file_bytes)
-        sh_train = find_sheet(
-            book, ["Train", "Training", "training2", "train", "training"]
-        )
-        sh_test = find_sheet(
-            book, ["Test", "Testing", "testing2", "test", "testing"]
-        )
+        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:
-            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.error("Missing required columns.")
-            st.stop()
+            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.error("Missing required columns."); st.stop()
         tr["UCS_Pred"] = model.predict(tr[FEATURES])
         te["UCS_Pred"] = model.predict(te[FEATURES])
 
-        st.session_state.results["Train"] = tr
-        st.session_state.results["Test"] = te
-        st.session_state.results["m_train"] = {
+        st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
+        st.session_state.results["m_train"]={
             "R": pearson_r(tr[TARGET], tr["UCS_Pred"]),
             "RMSE": rmse(tr[TARGET], tr["UCS_Pred"]),
             "MAE": mean_absolute_error(tr[TARGET], tr["UCS_Pred"])
         }
-        st.session_state.results["m_test"] = {
+        st.session_state.results["m_test"]={
             "R": pearson_r(te[TARGET], te["UCS_Pred"]),
             "RMSE": rmse(te[TARGET], te["UCS_Pred"]),
             "MAE": mean_absolute_error(te[TARGET], te["UCS_Pred"])
         }
 
-        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}
+        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.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['R']:.2f}")
-        c2.metric("RMSE", f"{m['RMSE']:.2f}")
-        c3.metric("MAE", f"{m['MAE']:.2f}")
+        c1,c2,c3 = st.columns(3)
+        c1.metric("R", f"{m['R']:.2f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
 
         # 2-column layout, big gap (prevents overlap)
         col_cross, col_track = st.columns([3, 2], gap="large")
@@ -583,18 +552,16 @@ if st.session_state.app_step == "dev":
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
         if "Train" in st.session_state.results:
-            with tab1:
-                _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)
 # =========================
 if st.session_state.app_step == "validate":
     st.sidebar.header("Validate the Model")
-    up = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx", "xls"])
+    up = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"])
     if up is not None:
         book = read_book_bytes(up.getvalue())
         if book:
@@ -603,78 +570,54 @@ if st.session_state.app_step == "validate":
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
         preview_modal(read_book_bytes(up.getvalue()))
     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()
-    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
-        st.session_state.app_step = "predict"
-        st.rerun()
+    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()
 
     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]
+        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.error("Missing required columns.")
-            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
+        st.session_state.results["Validate"]=df
 
-        ranges = st.session_state.train_ranges
-        oor_pct = 0.0
-        tbl = None
+        ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=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)
-            oor_pct = float(any_viol.mean() * 100.0)
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
+            oor_pct = float(any_viol.mean()*100.0)
             if any_viol.any():
                 tbl = df.loc[any_viol, FEATURES].copy()
                 for c in FEATURES:
-                    if pd.api.types.is_numeric_dtype(tbl[c]):
-                        tbl[c] = tbl[c].round(2)
-                tbl["Violations"] = pd.DataFrame(
-                    {f: (df[f] < ranges[f][0]) | (df[f] > ranges[f][1]) for f in FEATURES}
-                ).loc[any_viol].apply(lambda r: ", ".join([c for c, v in r.items() if v]), axis=1)
-        st.session_state.results["m_val"] = {
+                    if pd.api.types.is_numeric_dtype(tbl[c]): tbl[c] = tbl[c].round(2)
+                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(lambda r:", ".join([c for c,v in r.items() if v]), axis=1)
+        st.session_state.results["m_val"]={
             "R": pearson_r(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.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
 
     if "Validate" in st.session_state.results:
         m = st.session_state.results["m_val"]
-        c1, c2, c3 = st.columns(3)
-        c1.metric("R", f"{m['R']:.2f}")
-        c2.metric("RMSE", f"{m['RMSE']:.2f}")
-        c3.metric("MAE", f"{m['MAE']:.2f}")
+        c1,c2,c3 = st.columns(3)
+        c1.metric("R", f"{m['R']:.2f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
 
         col_cross, col_track = st.columns([3, 2], gap="large")
         with col_cross:
             st.pyplot(
-                cross_plot_static(
-                    st.session_state.results["Validate"][TARGET],
-                    st.session_state.results["Validate"]["UCS_Pred"]
-                ),
+                cross_plot_static(st.session_state.results["Validate"][TARGET],
+                                  st.session_state.results["Validate"]["UCS_Pred"]),
                 use_container_width=True
             )
         with col_track:
             st.plotly_chart(
                 track_plot(st.session_state.results["Validate"], include_actual=True),
-                use_container_width=True,
-                config={"displayModeBar": False, "scrollZoom": True}
+                use_container_width=True, config={"displayModeBar": False, "scrollZoom": True}
             )
 
         sv = st.session_state.results["sv_val"]
-        if sv["oor"] > 0:
-            st.warning("Some inputs fall outside **training min–max** ranges.")
+        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):*")
             df_centered_rounded(st.session_state.results["oor_tbl"])
@@ -684,7 +627,7 @@ if st.session_state.app_step == "validate":
 # =========================
 if st.session_state.app_step == "predict":
     st.sidebar.header("Prediction (No Actual UCS)")
-    up = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx", "xls"])
+    up = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"])
     if up is not None:
         book = read_book_bytes(up.getvalue())
         if book:
@@ -693,52 +636,41 @@ if st.session_state.app_step == "predict":
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
         preview_modal(read_book_bytes(up.getvalue()))
     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()
+    if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
 
     if go_btn and up is not None:
-        book = read_book_bytes(up.getvalue())
-        name = list(book.keys())[0]
+        book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
         df = book[name].copy()
-        if not ensure_cols(df, FEATURES):
-            st.error("Missing required columns.")
-            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
+        st.session_state.results["PredictOnly"]=df
 
-        ranges = st.session_state.train_ranges
-        oor_pct = 0.0
+        ranges = st.session_state.train_ranges; oor_pct = 0.0
         if ranges:
-            any_viol = pd.DataFrame(
-                {f: (df[f] < ranges[f][0]) | (df[f] > ranges[f][1]) for f in FEATURES}
-            ).any(axis=1)
-            oor_pct = float(any_viol.mean() * 100.0)
-        st.session_state.results["sv_pred"] = {
-            "n": 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": oor_pct
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
+            oor_pct = float(any_viol.mean()*100.0)
+        st.session_state.results["sv_pred"]={
+            "n":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":oor_pct
         }
 
     if "PredictOnly" in st.session_state.results:
-        df = st.session_state.results["PredictOnly"]
-        sv = st.session_state.results["sv_pred"]
+        df = st.session_state.results["PredictOnly"]; sv = st.session_state.results["sv_pred"]
 
-        col_left, col_right = st.columns([2, 3], gap="large")
+        col_left, col_right = st.columns([2,3], gap="large")
         with col_left:
             table = pd.DataFrame({
-                "Metric": ["# points", "Pred min", "Pred max", "Pred mean", "Pred std", "OOR %"],
-                "Value": [
-                    sv["n"],
-                    round(sv["pred_min"], 2),
-                    round(sv["pred_max"], 2),
-                    round(sv["pred_mean"], 2),
-                    round(sv["pred_std"], 2),
-                    f'{sv["oor"]:.1f}%'
-                ]
+                "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
+                "Value":  [sv["n"],
+                           round(sv["pred_min"],2),
+                           round(sv["pred_max"],2),
+                           round(sv["pred_mean"],2),
+                           round(sv["pred_std"],2),
+                           f'{sv["oor"]:.1f}%']
             })
             st.success("Predictions ready ✓")
             df_centered_rounded(table, hide_index=True)
@@ -746,8 +678,7 @@ if st.session_state.app_step == "predict":
         with col_right:
             st.plotly_chart(
                 track_plot(df, include_actual=False),
-                use_container_width=True,
-                config={"displayModeBar": False, "scrollZoom": True}
+                use_container_width=True, config={"displayModeBar": False, "scrollZoom": True}
             )
 
 # =========================