Update app.py

app.py

@@ -152,32 +152,86 @@ def _normalize_depr_columns(df_in: pd.DataFrame) -> pd.DataFrame:
     out = out[~out[["Begin BV","Depreciation","Accum Dep","End BV"]].isna().all(axis=1)].reset_index(drop=True)
     return out
 
+# Monday Aug 11 New helpers
+def build_sl_schedule(cost: float, salvage: float, life: int, start_year: int):
+    """Return the straight-line depreciation schedule as a DataFrame."""
+    dep = (cost - salvage) / life
+    years = [start_year + i for i in range(life)]
+    begin_bv, dep_col, accum, end_bv = [], [], [], []
+    b = cost
+    acc = 0.0
+    for _ in years:
+        begin_bv.append(b)
+        dep_col.append(dep)
+        acc += dep
+        accum.append(acc)
+        b = b - dep
+        end_bv.append(b)
+    out = pd.DataFrame(
+        {
+            "Year": years,
+            "Begin BV": begin_bv,
+            "Depreciation": dep_col,
+            "Accum Dep": accum,
+            "End BV": end_bv,
+        }
+    )
+    return out
+
+def audit_against_expected(expected: pd.DataFrame, actual: pd.DataFrame):
+    """Row-by-row deltas (actual - expected). Assumes normalized col names."""
+    if actual is None or actual.empty:
+        return pd.DataFrame(), "No student table found to check."
+    # align only overlapping years
+    merged = expected.merge(
+        actual[["Year","Begin BV","Depreciation","Accum Dep","End BV"]],
+        on="Year", how="inner", suffixes=("_exp","_act")
+    )
+    if merged.empty:
+        return pd.DataFrame(), "No matching years between expected and uploaded table."
+    deltas = pd.DataFrame({"Year": merged["Year"]})
+    for c in ["Begin BV","Depreciation","Accum Dep","End BV"]:
+        deltas[c + " Δ"] = merged[f"{c}_act"] - merged[f"{c}_exp"]
+    # first mismatch helper
+    first_bad = None
+    for _, r in deltas.iterrows():
+        if any(abs(r[col]) > 1e-6 for col in deltas.columns if col.endswith("Δ")):
+            first_bad = int(r["Year"])
+            break
+    msg = (
+        "All good 🎉 Straight‑line matches your table."
+        if first_bad is None
+        else f"First mismatch at year {first_bad}. Remember: Dep=(Cost−Salvage)/Life and Accum_t=Accum_(t−1)+Dep."
+    )
+    return deltas, msg
+
+
+
 # ---------- Gradio callbacks ----------
 def handle_docx(file):
     if file is None:
-        return "(no file)", None, None
+        return "(no file)", None, None, {}, pd.DataFrame()
     df_raw, header = _docx_to_table_and_text(file.name if hasattr(file, "name") else file)
     params = _extract_params(header or "")
     df_norm = _normalize_depr_columns(df_raw) if df_raw is not None else None
-    return header or "(no text found)", params, df_norm
+    return header or "(no text found)", params, df_norm, params, (df_norm if df_norm is not None else pd.DataFrame())
 
 def handle_image(img):
     if img is None:
-        return "(no image)", None, None, None
-    # gradio gives a numpy array; convert to PIL
-    if not isinstance(img, Image.Image):
-        from PIL import Image as PILImage
-        pil = PILImage.fromarray(img)
-    else:
-        pil = img
+        return "(no image)", None, None, None, {}, pd.DataFrame()
+    from PIL import Image as PILImage
+    pil = img if isinstance(img, PILImage.Image) else PILImage.fromarray(img)
     ocr_text = _image_to_text(pil)
     params = _extract_params(ocr_text or "")
     df_raw = _table_from_ocr_text(ocr_text or "")
     df_norm = _normalize_depr_columns(df_raw) if df_raw is not None else None
-    return ocr_text or "(empty OCR)", params, df_raw, df_norm
+    return ocr_text or "(empty OCR)", params, df_raw, df_norm, params, (df_norm if df_norm is not None else pd.DataFrame())
+
 
 # ---------- UI ----------
 with gr.Blocks(title="Jerry • HW Intake (Echo)") as demo:
+    last_params = gr.State({})
+    last_table  = gr.State(pd.DataFrame())
     gr.Markdown("## Jerry (TA) – Homework Intake\nThis Space **only reads and echoes** your files.\nNext step will add solving & coaching.")
     with gr.Tab("Upload .docx"):
         docx_in = gr.File(file_types=[".docx"], label="Homework .docx")
@@ -196,6 +250,60 @@ with gr.Blocks(title="Jerry • HW Intake (Echo)") as demo:
         norm_df = gr.Dataframe(label="Detected table (normalized)", interactive=False)
         btn2.click(handle_image, inputs=img_in, outputs=[ocr_txt, params_json2, raw_df, norm_df])
 
+    with gr.Tab("Straight‑Line • Solve & Check"):
+    gr.Markdown("Enter params (auto-filled if detected) → build the correct SL schedule → compare to your uploaded table.")
+    with gr.Row():
+        in_cost = gr.Number(label="Cost", value=0.0)
+        in_salv = gr.Number(label="Salvage", value=0.0)
+        in_life = gr.Number(label="Life (years)", value=10, precision=0)
+        in_year = gr.Number(label="Start year", value=2025, precision=0)
+    btn_build = gr.Button("Build expected schedule")
+    expected_df = gr.Dataframe(label="Expected (SL) schedule", interactive=False)
+    btn_check = gr.Button("Check against uploaded table")
+    deltas_df  = gr.Dataframe(label="Differences (student − expected)", interactive=False)
+    coach_txt  = gr.Markdown()
+
+    def fill_from_state(p):
+        # prefill controls when we have parsed params
+        p = p or {}
+        return (
+            p.get("cost", 0.0),
+            p.get("salvage", 0.0),
+            p.get("life", 10),
+            p.get("start_year", pd.Timestamp.now().year),
+        )
+
+    def build_cb(cost, salv, life, year):
+        try:
+            df = build_sl_schedule(float(cost), float(salv), int(life), int(year))
+        except Exception as e:
+            return pd.DataFrame([{"error": str(e)}])
+        return df
+
+    def check_cb(cost, salv, life, year, table):
+        exp = build_sl_schedule(float(cost), float(salv), int(life), int(year))
+        deltas, msg = audit_against_expected(exp, table if isinstance(table, pd.DataFrame) else pd.DataFrame())
+        return deltas, msg
+
+    # Wire up
+    btn_build.click(build_cb, [in_cost, in_salv, in_life, in_year], [expected_df])
+    btn_check.click(check_cb, [in_cost, in_salv, in_life, in_year, last_table], [deltas_df, coach_txt])
+
+    btn1.click(handle_docx, inputs=docx_in,
+           outputs=[header_txt, params_json, table_df, last_params, last_table])
+    btn2.click(handle_image, inputs=img_in,
+           outputs=[ocr_txt, params_json2, raw_df, norm_df, last_params, last_table])
+
+    # When params state changes, prefill inputs
+    last_params.change(lambda p: fill_from_state(p), inputs=last_params,
+                   outputs=[in_cost, in_salv, in_life, in_year])
+
+    
+    # Auto-fill inputs whenever we parse new params
+    def prefill_inputs(p): return fill_from_state(p)
+    params_from_docx = gr.EventListener(last_params, triggers=["change"])
+    params_from_img  = gr.EventListener(last_params, triggers=["change"])
+    
     gr.Markdown("— Echo mode finished. When this looks good, we’ll plug in the SL solver + coaching.")
 
 if __name__ == "__main__":