Update app.py

app.py

@@ -22,9 +22,7 @@ TARGET = "UCS"
 MODELS_DIR = Path("models")
 DEFAULT_MODEL = MODELS_DIR / "ucs_rf.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
-
-# Updated colors for a dark blue theme
-COLORS = {"pred": "#4A90E2", "actual": "#FFC107", "ref": "#B0B0B0"}
+COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
 # ---- Plot sizing controls ----
 CROSS_W = 450      # px (matplotlib figure size; Streamlit will still scale)
@@ -38,44 +36,39 @@ 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 for the sticky header and message box
+# This is the new CSS block with the added h1 color rule
 st.markdown("""
 <style>
-/* Changed to a lighter blue for visibility on a dark background */
-.app-title {
-    color: #89b4f2;
-    font-weight:800;
-    font-size:1.2rem;
+/* 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;
 }
 
-/* Changed background to a dark blue to match the theme */
+/* CSS to make the header sticky */
 .fixed-header-container {
     position: sticky;
     top: 0;
     z-index: 1000;
-    background-color: #0a192f;
+    background-color: #f0f2f6; /* Ensure sticky header background matches app background */
     padding: 10px 0;
-    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.3);
-}
-
-/* Changed to a light gray/blue to be visible on the dark background */
-.info-box {
-    background-color: #172a45;
-    color: #b1c7e0;
-    padding: 10px;
-    border-radius: 5px;
-    margin-bottom: 1rem;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
 }
 
+/* CSS to ensure main content doesn't get hidden under the sticky header */
 .main .block-container {
-    padding-top: 250px;
+    padding-top: 250px; /* Adjust this value to match the height of your sticky header */
 }
 
 /* General CSS */
 .brand-logo { width: 16px; height: auto; object-fit: contain; }
 .sidebar-header { display:flex; align-items:center; gap:12px; }
 .sidebar-header .text h1 { font-size: 1.05rem; margin:0; line-height:1.1; }
-.sidebar-header .text .tag { font-size: .85rem; color:#b1c7e0; margin:2px 0 0; } /* Changed color */
+.sidebar-header .text .tag { font-size: .85rem; color:#6b7280; margin:2px 0 0; }
 .centered-container {
     display: flex;
     flex-direction: column;
@@ -85,24 +78,37 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
+
+# Hide uploader helper text ("Drag and drop file here", limits, etc.)
+st.markdown("""
+<style>
+/* Older builds (helper wrapped in a Markdown container) */
+section[data-testid="stFileUploader"] div[data-testid="stMarkdownContainer"]{display:none !important;}
+/* 1.31–1.34: helper is the first child in the dropzone */
+section[data-testid="stFileUploader"] [data-testid="stFileUploaderDropzone"] > div:first-child{display:none !important;}
+/* 1.35+: explicit helper container */
+section[data-testid="stFileUploader"] [data-testid="stFileUploaderInstructions"]{display:none !important;}
+/* Fallback: any paragraph/small text inside the uploader */
+section[data-testid="stFileUploader"] p, section[data-testid="stFileUploader"] small{display:none !important;}
+</style>
+""", unsafe_allow_html=True)
+
 # Make the Preview expander title & tabs sticky (pinned to the top)
 st.markdown("""
 <style>
-/* Updated to a dark background for consistency */
 div[data-testid="stExpander"] > details > summary {
-    position: sticky;
-    top: 0;
-    z-index: 10;
-    background: #0a192f;
-    border-bottom: 1px solid #172a45;
+  position: sticky;
+  top: 0;
+  z-index: 10;
+  background: #fff;
+  border-bottom: 1px solid #eee;
 }
-/* Updated to a dark background for consistency */
 div[data-testid="stExpander"] div[data-baseweb="tab-list"] {
-    position: sticky;
-    top: 42px;
-    z-index: 9;
-    background: #0a192f;
-    padding-top: 6px;
+  position: sticky;
+  top: 42px;    /* adjust if your expander header height differs */
+  z-index: 9;
+  background: #fff;
+  padding-top: 6px;
 }
 </style>
 """, unsafe_allow_html=True)
@@ -140,8 +146,8 @@ def add_password_gate() -> None:
     st.sidebar.markdown(f"""
         <div class="centered-container">
             <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-            <div class='app-title' style='margin-top: 10px;'>ST_GeoMech_UCS</div>
-            <div style='color:#b1c7e0;'>Smart Thinking • Secure Access</div>
+            <div style='font-weight:800;font-size:1.2rem; margin-top: 10px;'>ST_GeoMech_UCS</div>
+            <div style='color:#667085;'>Smart Thinking • Secure Access</div>
         </div>
         """, unsafe_allow_html=True
     )
@@ -213,7 +219,7 @@ def df_centered_rounded(df: pd.DataFrame, hide_index=True):
 # =========================
 def cross_plot_static(actual, pred):
     a = pd.Series(actual, dtype=float)
-    p = pd.Series(pred, dtype=float)
+    p = pd.Series(pred,    dtype=float)
 
     fixed_min, fixed_max = 6000, 10000
     ticks = np.arange(fixed_min, fixed_max + 1, 1000)
@@ -224,9 +230,6 @@ def cross_plot_static(actual, pred):
         dpi=dpi,
         constrained_layout=False
     )
-    # Set the background color of the plot
-    fig.patch.set_facecolor('#0a192f')
-    ax.set_facecolor('#0a192f')
 
     ax.scatter(a, p, s=16, c=COLORS["pred"], alpha=0.9, linewidths=0)
     ax.plot([fixed_min, fixed_max], [fixed_min, fixed_max],
@@ -234,21 +237,22 @@ def cross_plot_static(actual, pred):
 
     ax.set_xlim(fixed_min, fixed_max)
     ax.set_ylim(fixed_min, fixed_max)
+    ax.set_xticks(ticks)
+    ax.set_yticks(ticks)
     ax.set_aspect("equal", adjustable="box")  # true 45°
 
     fmt = FuncFormatter(lambda x, _: f"{int(x):,}")
     ax.xaxis.set_major_formatter(fmt)
     ax.yaxis.set_major_formatter(fmt)
 
-    # Changed text and tick colors to a light blue for contrast
-    ax.set_xlabel("Actual UCS (psi)", fontweight="bold", fontsize=12, color="#E0E7FF")
-    ax.set_ylabel("Predicted UCS (psi)", fontweight="bold", fontsize=12, color="#E0E7FF")
-    ax.tick_params(labelsize=10, colors="#E0E7FF")
+    ax.set_xlabel("Actual UCS (psi)", fontweight="bold", fontsize=12, color="black")
+    ax.set_ylabel("Predicted UCS (psi)", fontweight="bold", fontsize=12, color="black")
+    ax.tick_params(labelsize=10, colors="black")
 
     ax.grid(True, linestyle=":", alpha=0.3)
     for spine in ax.spines.values():
         spine.set_linewidth(1.1)
-        spine.set_color("#A0A0A0") # Changed spine color to a lighter gray
+        spine.set_color("#444")
 
     fig.subplots_adjust(left=0.16, bottom=0.16, right=0.98, top=0.98)
     return fig
@@ -293,40 +297,38 @@ def track_plot(df, include_actual=True):
 
     fig.update_layout(
         height=TRACK_H, width=None,  # width auto-fits the column
-        # Updated background colors for dark theme
-        paper_bgcolor="#0a192f", plot_bgcolor="#0a192f",
+        paper_bgcolor="#fff", plot_bgcolor="#fff",
         margin=dict(l=64, r=16, t=36, b=48), hovermode="closest",
-        # Updated font color
-        font=dict(size=FONT_SZ, color="#E0E7FF"),
+        font=dict(size=FONT_SZ, color="#000"),
         legend=dict(
             x=0.98, y=0.05, xanchor="right", yanchor="bottom",
-            bgcolor="rgba(10,25,47,0.75)", bordercolor="#ccc", borderwidth=1
+            bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1
         ),
         legend_title_text=""
     )
 
-    # Bold, light blue axis titles & ticks
+    # Bold, black axis titles & ticks
     fig.update_xaxes(
         title_text="UCS (psi)",
-        title_font=dict(size=16, family=BOLD_FONT, color="#E0E7FF"),
-        tickfont=dict(size=11, family=BOLD_FONT, color="#E0E7FF"),
+        title_font=dict(size=16, family=BOLD_FONT, color="#000"),
+        tickfont=dict(size=11, family=BOLD_FONT, color="#000"),
         side="top",
         range=[xmin, xmax],
         ticks="outside",
         tickformat=",.0f",
         tickmode="auto",
         tick0=tick0,
-        showline=True, linewidth=1.2, linecolor="#A0A0A0", mirror=True,
-        showgrid=True, gridcolor="rgba(255,255,255,0.12)", automargin=True
+        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=ylab,
-        title_font=dict(size=16, family=BOLD_FONT, color="#E0E7FF"),
-        tickfont=dict(size=11, family=BOLD_FONT, color="#E0E7FF"),
+        title_font=dict(size=16, family=BOLD_FONT, color="#000"),
+        tickfont=dict(size=11, family=BOLD_FONT, color="#000"),
         range=y_range,
         ticks="outside",
-        showline=True, linewidth=1.2, linecolor="#A0A0A0", mirror=True,
-        showgrid=True, gridcolor="rgba(255,255,255,0.12)", automargin=True
+        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
 
     return fig
@@ -337,22 +339,17 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
     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", color="#E0E7FF"); ax.axis("off")
+        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)
-    fig.patch.set_facecolor('#0a192f')
     if n == 1: axes = [axes]
     idx = np.arange(1, len(df) + 1)
     for ax, col in zip(axes, cols):
-        ax.set_facecolor('#0a192f')
-        ax.plot(df[col], idx, '-', lw=1.4, color="#b1c7e0") # Light blue plot line
-        ax.set_xlabel(col, color="#b1c7e0"); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis() # Light blue labels
-        ax.tick_params(axis='both', colors='#b1c7e0') # Light blue ticks
+        ax.plot(df[col], idx, '-', lw=1.4, color="#333")
+        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
         ax.grid(True, linestyle=":", alpha=0.3)
-        for s in ax.spines.values():
-            s.set_visible(True)
-            s.set_edgecolor("#A0A0A0") # Lighter spine color
-    axes[0].set_ylabel("Point Index", color="#b1c7e0") # Light blue label
+        for s in ax.spines.values(): s.set_visible(True)
+    axes[0].set_ylabel("Point Index")
     return fig
 
 # Modal wrapper (Streamlit compatibility)
@@ -440,17 +437,12 @@ st.session_state.setdefault("dev_preview",False)
 st.sidebar.markdown(f"""
     <div class="centered-container">
         <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-        <div class='app-title'>ST_GeoMech_UCS</div>
-        <div style='color:#b1c7e0;'>Real-Time UCS Tracking While Drilling</div>
+        <div style='font-weight:800;font-size:1.2rem;'>ST_GeoMech_UCS</div>
+        <div style='color:#667085;'>Real-Time UCS Tracking While Drilling</div>
     </div>
     """, 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.
@@ -484,7 +476,9 @@ 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"
@@ -492,7 +486,8 @@ 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
@@ -509,47 +504,70 @@ 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")
@@ -565,16 +583,18 @@ 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:
@@ -583,54 +603,78 @@ 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"])
@@ -640,7 +684,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:
@@ -649,41 +693,52 @@ 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)
@@ -691,7 +746,8 @@ 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}
             )
 
 # =========================
@@ -700,10 +756,10 @@ if st.session_state.app_step == "predict":
 st.markdown("---")
 st.markdown(
     """
-    <div style='text-align:center; color:#b1c7e0; line-height:1.6'>
+    <div style='text-align:center; color:#6b7280; line-height:1.6'>
       ST_GeoMech_UCS • © Smart Thinking<br/>
       <strong>Visit our website:</strong> <a href='https://www.smartthinking.com.sa' target='_blank'>smartthinking.com.sa</a>
     </div>
     """,
     unsafe_allow_html=True
-)
+)