Update app.py

app.py

@@ -200,7 +200,7 @@ def df_centered_rounded(df: pd.DataFrame, hide_index=True):
     )
     st.dataframe(styler, use_container_width=True, hide_index=hide_index)
 
-# === Excel export helpers ======================================================
+# === Excel export helpers =================================================
 def _excel_engine() -> str:
     try:
         import xlsxwriter  # noqa: F401
@@ -228,16 +228,50 @@ def _summary_table(df: pd.DataFrame, cols: list[str]) -> pd.DataFrame:
             .agg(['min','max','mean','std'])
             .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
             .reset_index(names="Field"))
-    return _round_numeric(tbl)
+    return tbl
 
 def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
     if not ranges:
         return pd.DataFrame()
     df = pd.DataFrame(ranges).T.reset_index()
     df.columns = ["Feature", "Min", "Max"]
-    return _round_numeric(df)
+    return df
 
-def build_export_workbook() -> tuple[bytes|None, str|None, list[str]]:
+def _excel_autofit(writer, sheet_name: str, df: pd.DataFrame, min_w: int = 8, max_w: int = 40):
+    """Auto-fit columns when using xlsxwriter."""
+    try:
+        import xlsxwriter  # noqa: F401
+    except Exception:
+        return
+    ws = writer.sheets[sheet_name]
+    # header
+    for i, col in enumerate(df.columns):
+        series = df[col].astype(str)
+        max_len = max([len(str(col))] + series.map(len).tolist())
+        ws.set_column(i, i, max(min_w, min(max_len + 2, max_w)))
+    # freeze header row
+    ws.freeze_panes(1, 0)
+
+def _add_sheet(sheets: dict, order: list, name: str, df: pd.DataFrame, ndigits: int):
+    if df is None or df.empty:
+        return
+    sheets[name] = _round_numeric(df, ndigits)
+    order.append(name)
+
+def _available_sections():
+    """Compute which sections exist, to build a sensible default list."""
+    res = st.session_state.get("results", {})
+    sections = []
+    if "Train" in res:        sections += ["Training","Training_Metrics","Training_Summary"]
+    if "Test" in res:         sections += ["Testing","Testing_Metrics","Testing_Summary"]
+    if "Validate" in res:     sections += ["Validation","Validation_Metrics","Validation_Summary","Validation_OOR"]
+    if "PredictOnly" in res:  sections += ["Prediction","Prediction_Summary","Prediction_OOR"]
+    if st.session_state.get("train_ranges"): sections += ["Training_Ranges"]
+    sections += ["Info"]
+    return sections
+
+def build_export_workbook(selected: list[str], ndigits: int = 2) -> tuple[bytes|None, str|None, list[str]]:
+    """Builds an in-memory Excel workbook based on selected sheet names."""
     res = st.session_state.get("results", {})
     if not res:
         return None, None, []
@@ -246,93 +280,116 @@ def build_export_workbook() -> tuple[bytes|None, str|None, list[str]]:
     order: list[str] = []
 
     # Training
-    if "Train" in res:
-        tr = _round_numeric(res["Train"])
-        sheets["Training"] = tr; order.append("Training")
-        m = res.get("m_train", {})
-        if m:
-            sheets["Training_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Training_Metrics")
-        tr_cols = FEATURES + ([TARGET] if TARGET in tr.columns else []) + ([PRED_COL] if PRED_COL in tr.columns else [])
-        s = _summary_table(tr, tr_cols)
-        if not s.empty:
-            sheets["Training_Summary"] = s; order.append("Training_Summary")
+    if "Training" in selected and "Train" in res:
+        _add_sheet(sheets, order, "Training", res["Train"], ndigits)
+    if "Training_Metrics" in selected and res.get("m_train"):
+        _add_sheet(sheets, order, "Training_Metrics", pd.DataFrame([res["m_train"]]), ndigits)
+    if "Training_Summary" in selected and "Train" in res:
+        tr_cols = FEATURES + [c for c in ["GR_Actual","GR_Pred"] if c in res["Train"].columns]
+        _add_sheet(sheets, order, "Training_Summary", _summary_table(res["Train"], tr_cols), ndigits)
 
     # Testing
-    if "Test" in res:
-        te = _round_numeric(res["Test"])
-        sheets["Testing"] = te; order.append("Testing")
-        m = res.get("m_test", {})
-        if m:
-            sheets["Testing_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Testing_Metrics")
-        te_cols = FEATURES + ([TARGET] if TARGET in te.columns else []) + ([PRED_COL] if PRED_COL in te.columns else [])
-        s = _summary_table(te, te_cols)
-        if not s.empty:
-            sheets["Testing_Summary"] = s; order.append("Testing_Summary")
+    if "Testing" in selected and "Test" in res:
+        _add_sheet(sheets, order, "Testing", res["Test"], ndigits)
+    if "Testing_Metrics" in selected and res.get("m_test"):
+        _add_sheet(sheets, order, "Testing_Metrics", pd.DataFrame([res["m_test"]]), ndigits)
+    if "Testing_Summary" in selected and "Test" in res:
+        te_cols = FEATURES + [c for c in ["GR_Actual","GR_Pred"] if c in res["Test"].columns]
+        _add_sheet(sheets, order, "Testing_Summary", _summary_table(res["Test"], te_cols), ndigits)
 
     # Validation
-    if "Validate" in res:
-        va = _round_numeric(res["Validate"])
-        sheets["Validation"] = va; order.append("Validation")
-        m = res.get("m_val", {})
-        if m:
-            sheets["Validation_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Validation_Metrics")
-        sv = res.get("sv_val", {})
-        if sv:
-            sheets["Validation_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Validation_Summary")
-        oor_tbl = res.get("oor_tbl")
-        if oor_tbl is not None and isinstance(oor_tbl, pd.DataFrame) and not oor_tbl.empty:
-            sheets["Validation_OOR"] = _round_numeric(oor_tbl.reset_index(drop=True)); order.append("Validation_OOR")
-
-    # Prediction (no actual)
-    if "PredictOnly" in res:
-        pr = _round_numeric(res["PredictOnly"])
-        sheets["Prediction"] = pr; order.append("Prediction")
-        sv = res.get("sv_pred", {})
-        if sv:
-            sheets["Prediction_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Prediction_Summary")
-
-    # Training ranges (from dev step)
-    tr_ranges = st.session_state.get("train_ranges")
-    if tr_ranges:
-        rr = _train_ranges_df(tr_ranges)
-        if not rr.empty:
-            sheets["Training_Ranges"] = rr; order.append("Training_Ranges")
-
-    # Info sheet
-    info = pd.DataFrame([
-        {"Key": "Target", "Value": TARGET},
-        {"Key": "Features", "Value": ", ".join(FEATURES)},
-        {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
-    ])
-    sheets["Info"] = info; order.append("Info")
-
-    # Write workbook
+    if "Validation" in selected and "Validate" in res:
+        _add_sheet(sheets, order, "Validation", res["Validate"], ndigits)
+    if "Validation_Metrics" in selected and res.get("m_val"):
+        _add_sheet(sheets, order, "Validation_Metrics", pd.DataFrame([res["m_val"]]), ndigits)
+    if "Validation_Summary" in selected and res.get("sv_val"):
+        _add_sheet(sheets, order, "Validation_Summary", pd.DataFrame([res["sv_val"]]), ndigits)
+    if "Validation_OOR" in selected and isinstance(res.get("oor_tbl"), pd.DataFrame) and not res["oor_tbl"].empty:
+        _add_sheet(sheets, order, "Validation_OOR", res["oor_tbl"].reset_index(drop=True), ndigits)
+
+    # Prediction
+    if "Prediction" in selected and "PredictOnly" in res:
+        _add_sheet(sheets, order, "Prediction", res["PredictOnly"], ndigits)
+    if "Prediction_Summary" in selected and res.get("sv_pred"):
+        _add_sheet(sheets, order, "Prediction_Summary", pd.DataFrame([res["sv_pred"]]), ndigits)
+    if "Prediction_OOR" in selected and isinstance(res.get("oor_tbl_pred"), pd.DataFrame) and not res["oor_tbl_pred"].empty:
+        _add_sheet(sheets, order, "Prediction_OOR", res["oor_tbl_pred"].reset_index(drop=True), ndigits)
+
+    # Training ranges
+    if "Training_Ranges" in selected and st.session_state.get("train_ranges"):
+        rr = _train_ranges_df(st.session_state["train_ranges"])
+        _add_sheet(sheets, order, "Training_Ranges", rr, ndigits)
+
+    # Info
+    if "Info" in selected:
+        info = pd.DataFrame([
+            {"Key": "AppName",          "Value": APP_NAME},
+            {"Key": "Tagline",          "Value": TAGLINE},
+            {"Key": "Target",           "Value": TARGET},
+            {"Key": "TargetTransform",  "Value": TARGET_TRANSFORM},
+            {"Key": "ActualColumn",     "Value": ACTUAL_COL},
+            {"Key": "Features",         "Value": ", ".join(FEATURES)},
+            {"Key": "ExportedAt",       "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
+        ])
+        _add_sheet(sheets, order, "Info", info, ndigits)
+
+    if not order:
+        return None, None, []
+
+    # Write workbook to memory
     bio = io.BytesIO()
-    with pd.ExcelWriter(bio, engine=_excel_engine()) as writer:
+    engine = _excel_engine()
+    with pd.ExcelWriter(bio, engine=engine) as writer:
         for name in order:
             df = sheets[name]
             df.to_excel(writer, sheet_name=_excel_safe_name(name), index=False)
+            _excel_autofit(writer, _excel_safe_name(name), df)
     bio.seek(0)
 
-    fname = f"YM_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+    fname = f"GR_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
     return bio.getvalue(), fname, order
 
 def render_export_button(key: str = "export_main") -> None:
-    data, fname, names = build_export_workbook()
     st.divider()
     st.markdown("### Export to Excel")
+
+    # Defaults: include everything that currently exists
+    default_sections = _available_sections()
+    all_sections = [
+        "Training","Training_Metrics","Training_Summary",
+        "Testing","Testing_Metrics","Testing_Summary",
+        "Validation","Validation_Metrics","Validation_Summary","Validation_OOR",
+        "Prediction","Prediction_Summary","Prediction_OOR",
+        "Training_Ranges","Info"
+    ]
+    selected = st.multiselect(
+        "Sheets to include",
+        options=all_sections,
+        default=default_sections,
+        help="Choose which sheets to include in the Excel export."
+    )
+
+    c1, c2, c3 = st.columns([1,1,2])
+    with c1:
+        ndigits = st.number_input("Rounding (decimals)", min_value=0, max_value=6, value=2, step=1)
+    with c2:
+        base_name = st.text_input("Base filename", value="GR_Export")
+    with c3:
+        st.caption("• Columns auto-fit & header row frozen (if xlsxwriter is available).")
+
+    data, default_fname, names = build_export_workbook(selected=selected, ndigits=int(ndigits))
+
     if names:
-        st.caption("Includes sheets: " + ", ".join(names))
+        st.caption("Will include: " + ", ".join(names))
     st.download_button(
         label="⬇️ Export Excel",
         data=(data or b""),
-        file_name=(fname or "YM_Export.xlsx"),
+        file_name=((base_name or "GR_Export") + "_" + datetime.now().strftime("%Y%m%d_%H%M%S") + ".xlsx") if data else "GR_Export.xlsx",
         mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
         disabled=(data is None),
-        help="Exports all available results, metrics, summaries, OOR, training ranges, and info.",
+        help="Exports selected sheets with optional rounding, auto-fit columns, and frozen headers.",
         key=key,
     )
-
 # =========================
 # Cross plot (Matplotlib) — auto-scaled for Ym
 # =========================
@@ -441,12 +498,17 @@ def track_plot(df, include_actual=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,
+  
+    fig.update_xaxes(
+        title_text="Ym",
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
         tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
-        range=y_range,
+        side="top",
+        range=[xmin, xmax],
         ticks="outside",
+        tickformat=",.0f",  # ← integer, thousands separated, no decimals
+        tickmode="auto",
+        tick0=tick0,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )