Update app.py

app.py

@@ -4,14 +4,17 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 import joblib
+
+# Matplotlib remains for the preview modal (tracks + stats)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
-from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
 
-# NEW: Plotly for interactive charts (keeps styling the same)
+# Plotly for the main interactive charts
 import plotly.graph_objects as go
 
+from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
+
 # =========================
 # Defaults
 # =========================
@@ -95,46 +98,9 @@ def find_sheet(book, names):
         if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
-# ---------- ORIGINAL Matplotlib plotters (kept for reference) ----------
-def cross_plot(actual, pred, title, size=(3.9, 3.9)):
-    fig, ax = plt.subplots(figsize=size, dpi=100)
-    ax.scatter(actual, pred, s=14, alpha=0.85, color=COLORS["pred"])
-    lo = float(np.nanmin([actual.min(), pred.min()]))
-    hi = float(np.nanmax([actual.max(), pred.max()]))
-    pad = 0.03 * (hi - lo if hi > lo else 1.0)
-    ax.plot([lo - pad, hi + pad], [lo - pad, hi + pad], '--', lw=1.2, color=COLORS["ref"])
-    ax.set_xlim(lo - pad, hi + pad); ax.set_ylim(lo - pad, hi + pad)
-    ax.set_aspect('equal', 'box')
-    ax.set_xlabel("Actual UCS"); ax.set_ylabel("Predicted UCS"); ax.set_title(title)
-    ax.grid(True, ls=":", alpha=0.4)
-    return fig
-
-def depth_or_index_track(df, title=None, include_actual=True):
-    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
-    fig_w = 3.1
-    fig_h = 7.6 if depth_col is not None else 7.2
-    fig, ax = plt.subplots(figsize=(fig_w, fig_h), dpi=100)
-    if depth_col is not None:
-        ax.plot(df["UCS_Pred"], df[depth_col], '-', lw=1.8, color=COLORS["pred"], label="UCS_Pred")
-        if include_actual and TARGET in df.columns:
-            ax.plot(df[TARGET], df[depth_col], ':', lw=2.0, color=COLORS["actual"], alpha=0.95, label="UCS (actual)")
-        ax.set_ylabel(depth_col); ax.set_xlabel("UCS")
-        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
-    else:
-        idx = np.arange(1, len(df) + 1)
-        ax.plot(df["UCS_Pred"], idx, '-', lw=1.8, color=COLORS["pred"], label="UCS_Pred")
-        if include_actual and TARGET in df.columns:
-            ax.plot(df[TARGET], idx, ':', lw=2.0, color=COLORS["actual"], alpha=0.95, label="UCS (actual)")
-        ax.set_ylabel("Point Index"); ax.set_xlabel("UCS")
-        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
-    ax.grid(True, linestyle=":", alpha=0.4)
-    if title: ax.set_title(title, pad=8)
-    ax.legend(loc="best")
-    return fig
-
-# ---------- NEW: Plotly equivalents (interactive, same specs) ----------
-def cross_plot_interactive(actual, pred, title, size=(3.9, 3.9)):
-    """Interactive cross-plot with the same look: blue points, dashed 1:1, equal axes, grid, title."""
+# ---------- Plotly (interactive) charts ----------
+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."""
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
     lo = float(np.nanmin([a.min(), p.min()]))
@@ -144,96 +110,80 @@ def cross_plot_interactive(actual, pred, title, size=(3.9, 3.9)):
 
     fig = go.Figure()
 
-    # points
+    # Points (blue)
     fig.add_trace(go.Scatter(
-        x=a, y=p,
-        mode="markers",
+        x=a, y=p, mode="markers",
         marker=dict(size=6, color=COLORS["pred"]),
         hovertemplate="Actual: %{x:.2f}<br>Pred: %{y:.2f}<extra></extra>",
-        name="Points",
-        showlegend=False
+        showlegend=False, name="Points"
     ))
 
-    # 1:1
+    # 1:1 line (dashed grey)
     fig.add_trace(go.Scatter(
-        x=[x0, x1], y=[x0, x1],
-        mode="lines",
+        x=[x0, x1], y=[x0, x1], mode="lines",
         line=dict(color=COLORS["ref"], width=1.2, dash="dash"),
-        hoverinfo="skip",
-        name="1:1",
-        showlegend=False
+        hoverinfo="skip", showlegend=False, name="1:1"
     ))
 
     fig.update_layout(
-        title=title,
-        paper_bgcolor="#ffffff",
-        plot_bgcolor="#ffffff",
-        margin=dict(l=50, r=10, t=36, b=36),
-        hovermode="closest",
-        font=dict(size=13)
+        paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
+        margin=dict(l=50, r=10, t=10, b=36),
+        hovermode="closest", font=dict(size=13)
     )
     fig.update_xaxes(
         title_text="<b>Actual UCS</b>",
-        range=[x0, x1],
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
+        range=[x0, x1], ticks="outside",
+        showline=True, linewidth=1.2, linecolor="#444",
         showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        automargin=True
+        tickformat=",.0f", automargin=True
     )
     fig.update_yaxes(
         title_text="<b>Predicted UCS</b>",
-        range=[x0, x1],
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
+        range=[x0, x1], ticks="outside",
+        showline=True, linewidth=1.2, linecolor="#444",
         showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        scaleanchor="x", scaleratio=1,
+        tickformat=",.0f", scaleanchor="x", scaleratio=1,
         automargin=True
     )
-
-    # match your size ~ inches * 100 dpi
-    w = int(size[0] * 100)
-    h = 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 narrow/tall UCS track: blue solid pred, yellow dotted actual, top x-axis, inverted y."""
+    """Interactive UCS track: blue solid pred, yellow dotted actual, legend inside; x on top; y inverted."""
     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
+        y = df[depth_col]; y_label = depth_col
     else:
-        y = np.arange(1, len(df) + 1)
-        y_label = "Point Index"
+        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",
+        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",
+            x=df[TARGET], y=y, mode="lines",
             line=dict(color=COLORS["actual"], width=2.0, dash="dot"),
             name="UCS (actual)",
             hovertemplate="UCS (actual): %{x:.2f}<br>"+y_label+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
-        title=title if title else None,
-        paper_bgcolor="#ffffff",
-        plot_bgcolor="#ffffff",
-        margin=dict(l=60, r=10, t=36, b=36),
-        hovermode="closest",
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, x=0),
-        font=dict(size=13),
-        # keep it tall & narrow like your Matplotlib version (~3.1in x 7.6in @100dpi)
+        paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
+        margin=dict(l=60, r=10, t=10, 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_title_text="",
         width=int(3.1 * 100),
         height=int((7.6 if depth_col is not None else 7.2) * 100),
     )
@@ -241,53 +191,17 @@ def depth_or_index_track_interactive(df, title=None, include_actual=True):
         title_text="<b>UCS</b>", side="top",
         ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
         showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        automargin=True
+        tickformat=",.0f", automargin=True
     )
     fig.update_yaxes(
-        title_text=f"<b>{y_label}</b>",
-        autorange="reversed",
+        title_text=f"<b>{y_label}</b>", autorange="reversed",
         ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
         showgrid=True, gridcolor="rgba(0,0,0,0.12)",
         automargin=True
     )
     return fig
 
-def export_workbook(sheets_dict, summary_df=None):
-    try: import openpyxl  # noqa
-    except Exception: raise RuntimeError("Export requires openpyxl. Please add it to requirements or install it.")
-    buf = io.BytesIO()
-    with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-        for name, frame in sheets_dict.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)
-    return buf.getvalue()
-
-def toast(msg):
-    try: st.toast(msg)
-    except Exception: st.info(msg)
-
-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
-
-def inline_logo(path="logo.png") -> str:
-    try:
-        p = Path(path)
-        if not p.exists(): return ""
-        return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
-    except Exception:
-        return ""
-
-# ---------- Preview modal helpers (unchanged; still Matplotlib) ----------
+# ---------- Preview modal helpers (matplotlib) ----------
 def make_index_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
@@ -390,7 +304,12 @@ if meta_path.exists():
         FEATURES = meta.get("features", FEATURES); TARGET = meta.get("target", TARGET)
     except Exception: pass
 else:
-    infer = infer_features_from_model(model)
+    infer = None
+    try:
+        if hasattr(model, "feature_names_in_") and len(getattr(model, "feature_names_in_")):
+            infer = [str(x) for x in model.feature_names_in_]
+    except Exception:
+        pass
     if infer: FEATURES = infer
 
 # =========================
@@ -485,7 +404,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()))
@@ -530,7 +448,7 @@ 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 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
@@ -571,10 +489,9 @@ 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"); toast("Model run complete 🚀")
-            st.rerun()
+            status.update(label="Done ✓", state="complete"); st.rerun()
 
-    # Results (NOW USING INTERACTIVE PLOTS)
+    # 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:
@@ -585,7 +502,7 @@ if st.session_state.app_step == "dev":
                 left, right = st.columns([0.9, 0.55])
                 with left:
                     st.plotly_chart(
-                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], "Training: Actual vs Predicted", size=(3.9,3.9)),
+                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], size=(3.9,3.9)),
                         use_container_width=True, config={"displayModeBar": False}
                     )
                 with right:
@@ -601,7 +518,7 @@ if st.session_state.app_step == "dev":
                 left, right = st.columns([0.9, 0.55])
                 with left:
                     st.plotly_chart(
-                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], "Testing: Actual vs Predicted", size=(3.9,3.9)),
+                        cross_plot_interactive(df[TARGET], df["UCS_Pred"], size=(3.9,3.9)),
                         use_container_width=True, config={"displayModeBar": False}
                     )
                 with right:
@@ -620,11 +537,17 @@ if st.session_state.app_step == "dev":
             rows.append({"Split":"Test", **{k:round(v,6) for k,v in st.session_state.results["metrics_test"].items()}})
         summary_df = pd.DataFrame(rows) if rows else None
         try:
-            data_bytes = export_workbook(sheets, summary_df)
+            buf = io.BytesIO()
+            import openpyxl  # noqa
+            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)
             st.download_button("Export Development Results to Excel",
-                data=data_bytes, file_name="UCS_Dev_Results.xlsx",
+                data=buf.getvalue(), file_name="UCS_Dev_Results.xlsx",
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
-        except RuntimeError as e:
+        except Exception as e:
             st.warning(str(e))
 
 # =========================
@@ -703,10 +626,11 @@ if st.session_state.app_step == "predict":
         with left:
             if TARGET in st.session_state.results["Validate"].columns:
                 st.plotly_chart(
-                    cross_plot_interactive(st.session_state.results["Validate"][TARGET],
-                                           st.session_state.results["Validate"]["UCS_Pred"],
-                                           "Validation: Actual vs Predicted",
-                                           size=(3.9,3.9)),
+                    cross_plot_interactive(
+                        st.session_state.results["Validate"][TARGET],
+                        st.session_state.results["Validate"]["UCS_Pred"],
+                        size=(3.9,3.9)
+                    ),
                     use_container_width=True, config={"displayModeBar": False}
                 )
             else:
@@ -714,7 +638,8 @@ if st.session_state.app_step == "predict":
         with right:
             st.plotly_chart(
                 depth_or_index_track_interactive(
-                    st.session_state.results["Validate"], title=None,
+                    st.session_state.results["Validate"],
+                    title=None,
                     include_actual=(TARGET in st.session_state.results["Validate"].columns)
                 ),
                 use_container_width=True, config={"displayModeBar": False}
@@ -732,11 +657,17 @@ if st.session_state.app_step == "predict":
             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
         try:
-            data_bytes = export_workbook(sheets, summary_df)
+            buf = io.BytesIO()
+            import openpyxl  # noqa
+            with pd.ExcelWriter(buf, engine="openpyxl") as xw:
+                for nm, fr in sheets.items():
+                    fr.to_excel(xw, sheet_name=nm[:31], index=False)
+                if summary_df is not None:
+                    summary_df.to_excel(xw, sheet_name="Summary", index=False)
             st.download_button("Export Validation Results to Excel",
-                data=data_bytes, file_name="UCS_Validation_Results.xlsx",
+                data=buf.getvalue(), file_name="UCS_Validation_Results.xlsx",
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
-        except RuntimeError as e:
+        except Exception as e:
             st.warning(str(e))
 
 # =========================