Update app.py

app.py

@@ -44,7 +44,7 @@ def _guess_cols(df: pd.DataFrame):
     cols = list(df.columns)
     lower = {c: str(c).strip().lower() for c in cols}
 
-    # marks guess: column with max % numeric
+    # marks guess = column with most numeric values
     best_marks, best_score = cols[0], -1
     for c in cols:
         s = _safe_numeric(df[c])
@@ -54,12 +54,12 @@ def _guess_cols(df: pd.DataFrame):
             best_marks = c
 
     grade_guess = next((c for c in cols if "grade" in lower[c] or "grde" in lower[c]), cols[0])
-    student_guess = next((c for c in cols if any(k in lower[c] for k in ["student", "name", "id", "roll", "reg", "sno"])), cols[0])
 
+    # optional columns
     course_guess = next((c for c in cols if any(k in lower[c] for k in ["course", "module", "subject"])), None)
     section_guess = next((c for c in cols if any(k in lower[c] for k in ["section", "group", "batch", "class"])), None)
 
-    return student_guess, best_marks, grade_guess, course_guess, section_guess
+    return best_marks, grade_guess, course_guess, section_guess
 
 
 def _fig_to_png_bytes(fig):
@@ -70,100 +70,24 @@ def _fig_to_png_bytes(fig):
     return buf
 
 
-# =============================
-# Load Excel
-# =============================
-def load_excel(file_obj):
-    try:
-        file_bytes = _read_file_bytes(file_obj)
-        xls = pd.ExcelFile(io.BytesIO(file_bytes), engine="openpyxl")
-        sheets = xls.sheet_names or []
-        if not sheets:
-            raise ValueError("No sheets found in this workbook.")
-
-        sheet0 = sheets[0]
-        df = pd.read_excel(io.BytesIO(file_bytes), sheet_name=sheet0, engine="openpyxl")
-        df = _drop_useless_cols(df)
-
-        s_guess, m_guess, g_guess, c_guess, sec_guess = _guess_cols(df)
-        cols = list(df.columns)
-
-        # Filters (optional)
-        course_dd = gr.Dropdown(choices=["(all)"], value="(all)", interactive=False, visible=False, label="Course filter")
-        section_dd = gr.Dropdown(choices=["(all)"], value="(all)", interactive=False, visible=False, label="Section filter")
-
-        if c_guess and c_guess in df.columns:
-            course_vals = ["(all)"] + sorted(df[c_guess].astype(str).fillna("NA").unique().tolist())
-            course_dd = gr.Dropdown(choices=course_vals, value="(all)", interactive=True, visible=True, label="Course filter")
-
-        if sec_guess and sec_guess in df.columns:
-            sec_vals = ["(all)"] + sorted(df[sec_guess].astype(str).fillna("NA").unique().tolist())
-            section_dd = gr.Dropdown(choices=sec_vals, value="(all)", interactive=True, visible=True, label="Section filter")
-
-        return (
-            gr.Dropdown(choices=sheets, value=sheet0, interactive=True),
-            gr.Dropdown(choices=cols, value=s_guess, interactive=True),
-            gr.Dropdown(choices=cols, value=m_guess, interactive=True),
-            gr.Dropdown(choices=cols, value=g_guess, interactive=True),
-            gr.Dropdown(choices=cols, value=(c_guess or cols[0]), interactive=bool(c_guess), visible=bool(c_guess), label="Course column"),
-            gr.Dropdown(choices=cols, value=(sec_guess or cols[0]), interactive=bool(sec_guess), visible=bool(sec_guess), label="Section column"),
-            course_dd,
-            section_dd,
-            file_bytes,
-            sheet0,  # sheet_state
-        )
-    except Exception:
-        return (
-            gr.Dropdown(choices=[], value=None, interactive=False),
-            gr.Dropdown(choices=[], value=None, interactive=False),
-            gr.Dropdown(choices=[], value=None, interactive=False),
-            gr.Dropdown(choices=[], value=None, interactive=False),
-            gr.Dropdown(choices=[], value=None, interactive=False, visible=False),
-            gr.Dropdown(choices=[], value=None, interactive=False, visible=False),
-            gr.Dropdown(choices=["(all)"], value="(all)", interactive=False, visible=False),
-            gr.Dropdown(choices=["(all)"], value="(all)", interactive=False, visible=False),
-            None,
-            None,
-        )
-
-
-def read_sheet(sheet_name, file_bytes, course_col, section_col):
-    if not file_bytes:
-        raise ValueError("Upload Excel first.")
-    df = pd.read_excel(io.BytesIO(file_bytes), sheet_name=sheet_name, engine="openpyxl")
-    df = _drop_useless_cols(df)
-
-    course_dd = gr.Dropdown(choices=["(all)"], value="(all)", interactive=False, visible=False, label="Course filter")
-    section_dd = gr.Dropdown(choices=["(all)"], value="(all)", interactive=False, visible=False, label="Section filter")
-
-    if course_col and course_col in df.columns:
-        course_vals = ["(all)"] + sorted(df[course_col].astype(str).fillna("NA").unique().tolist())
-        course_dd = gr.Dropdown(choices=course_vals, value="(all)", interactive=True, visible=True, label="Course filter")
-
-    if section_col and section_col in df.columns:
-        sec_vals = ["(all)"] + sorted(df[section_col].astype(str).fillna("NA").unique().tolist())
-        section_dd = gr.Dropdown(choices=sec_vals, value="(all)", interactive=True, visible=True, label="Section filter")
-
-    return course_dd, section_dd, sheet_name
-
-
 def apply_filters(df, course_col, section_col, course_filter, section_filter):
     d = df.copy()
-    if course_col in d.columns and course_filter and course_filter != "(all)":
+    if course_col and course_col in d.columns and course_filter and course_filter != "(all)":
         d = d[d[course_col].astype(str).fillna("NA") == course_filter]
-    if section_col in d.columns and section_filter and section_filter != "(all)":
+    if section_col and section_col in d.columns and section_filter and section_filter != "(all)":
         d = d[d[section_col].astype(str).fillna("NA") == section_filter]
     return d
 
 
 # =============================
-# Analytics (NO student-level tables)
+# Core Insights (NO student tables)
 # =============================
 def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_col, course_filter, section_filter):
     if df is None or df.empty:
         raise gr.Error("Sheet is empty.")
 
     d = apply_filters(df, course_col, section_col, course_filter, section_filter).copy()
+
     d["_marks"] = _safe_numeric(d[marks_col]) if marks_col in d.columns else np.nan
     d["_grade"] = d[grade_col].astype(str).str.strip().replace({"nan": "NA"}) if grade_col in d.columns else "NA"
 
@@ -177,6 +101,7 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
     minv = float(valid["_marks"].min()) if n else 0.0
     maxv = float(valid["_marks"].max()) if n else 0.0
 
+    pass_mark = int(pass_mark)
     pass_count = int((valid["_marks"] >= pass_mark).sum()) if n else 0
     pass_rate = (pass_count / n * 100.0) if n else 0.0
 
@@ -190,10 +115,11 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
             pct_rows.append((f"P{p}", round(float(np.percentile(valid["_marks"], p)), 2)))
     percentiles_df = pd.DataFrame(pct_rows, columns=["Percentile", "Marks"]) if pct_rows else pd.DataFrame()
 
-    # Grade distribution + grade-to-marks mapping
+    # Grade distribution
     grade_dist = d["_grade"].value_counts(dropna=False).rename("count").to_frame().reset_index()
     grade_dist.columns = [grade_col, "count"]
 
+    # Grade to marks mapping
     grade_stats = (
         valid.groupby(d["_grade"])["_marks"]
         .agg(["count", "mean", "std", "min", "median", "max"])
@@ -202,7 +128,7 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
         .sort_values("mean", ascending=False)
     )
 
-    # Heaping: repeated marks
+    # Mark heaping (repeated marks)
     heaping_df = (
         valid["_marks"].round(0).astype(int)
         .value_counts().head(12)
@@ -210,7 +136,7 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
         .rename(columns={"index": "Mark"})
     )
 
-    # Outliers count (IQR)
+    # Outlier count (IQR)
     outlier_count = 0
     low_thr = high_thr = 0.0
     if n:
@@ -229,25 +155,23 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
     else:
         status = "RED"
 
-    # Teacher-friendly interpretation
+    # Teacher flags
     flags = []
     if missing > 0:
-        flags.append(f"{missing} missing mark(s) → verify before final approval.")
+        flags.append(f"{missing} missing mark(s) → verify.")
     if abs(skew) > 0.7:
-        flags.append("Skewed distribution → performance is not balanced (many low or many high).")
+        flags.append("Skewed distribution → performance not balanced.")
     if len(heaping_df) and heaping_df["count"].iloc[0] >= max(10, 0.06 * n):
-        flags.append("Heaping detected → many students share the same mark (rounding/marking pattern).")
+        flags.append("Heaping → many students share same mark (rounding/marking pattern).")
     if outlier_count > 0:
-        flags.append(f"{outlier_count} outlier(s) by IQR rule → check special cases.")
-
+        flags.append(f"{outlier_count} outlier(s) by IQR → check special cases.")
     flags_text = " | ".join(flags) if flags else "No major warning patterns detected."
 
     insight_text = (
-        f"Overall Status: {status}. Pass rate {pass_rate:.1f}% (Pass mark {pass_mark}). "
-        f"Avg {mean:.1f} (Std {std:.1f}); Min {minv:.1f}, Max {maxv:.1f}. "
-        f"Skew {skew:.2f}, Kurtosis {kurt:.2f}. "
-        f"Outliers (IQR): {outlier_count}. Missing marks: {missing}. "
-        f"Teacher flags: {flags_text}"
+        f"Status: {status}. Pass rate {pass_rate:.1f}% (Pass mark {pass_mark}). "
+        f"Avg {mean:.1f} (Std {std:.1f}), Min {minv:.1f}, Max {maxv:.1f}. "
+        f"Skew {skew:.2f}, Kurtosis {kurt:.2f}. Outliers: {outlier_count}. Missing: {missing}. "
+        f"Flags: {flags_text}"
     )
 
     kpi_df = pd.DataFrame(
@@ -267,31 +191,27 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
             ("Outlier low threshold (IQR)", round(low_thr, 2)),
             ("Outlier high threshold (IQR)", round(high_thr, 2)),
             ("Outlier count (IQR)", outlier_count),
-            ("Status", status),
             ("Teacher insight", insight_text),
         ],
         columns=["Metric", "Value"],
     )
 
-    # ---- Charts
-    # Histogram
+    # Charts
     fig1 = plt.figure()
     plt.hist(valid["_marks"].dropna(), bins=12)
     plt.title("Marks distribution (Histogram)")
     plt.xlabel("Marks")
     plt.ylabel("Students")
 
-    # CDF
     fig2 = plt.figure()
     xs = np.sort(valid["_marks"].dropna().values) if n else np.array([])
     ys = np.arange(1, len(xs) + 1) / len(xs) if len(xs) else np.array([])
     if len(xs):
         plt.plot(xs, ys)
-    plt.title("CDF (Proportion of students ≤ mark)")
+    plt.title("CDF (Proportion ≤ mark)")
     plt.xlabel("Marks")
     plt.ylabel("Proportion")
 
-    # Grade bar
     fig3 = plt.figure()
     gd = grade_dist.set_index(grade_col)["count"]
     plt.bar(gd.index.astype(str), gd.values)
@@ -300,7 +220,6 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
     plt.ylabel("Count")
     plt.xticks(rotation=45, ha="right")
 
-    # Boxplot by grade (if possible)
     fig4 = plt.figure()
     if not grade_stats.empty:
         order = grade_stats[grade_stats.columns[0]].tolist()
@@ -319,9 +238,7 @@ def compute_insights(df, marks_col, grade_col, pass_mark, course_col, section_co
 # =============================
 # PDF
 # =============================
-def make_pdf(kpi_df, percentiles_df, grade_dist, grade_stats, heaping_df,
-             fig1, fig2, fig3, fig4,
-             title="HoD Result Dashboard Report"):
+def make_pdf(kpi_df, percentiles_df, grade_dist, grade_stats, heaping_df, fig1, fig2, fig3, fig4):
     buf = io.BytesIO()
     c = canvas.Canvas(buf, pagesize=A4)
     width, height = A4
@@ -369,18 +286,16 @@ def make_pdf(kpi_df, percentiles_df, grade_dist, grade_stats, heaping_df,
         img = ImageReader(png)
         img_w = width - 4 * cm
         img_h = 7.0 * cm
-
         if y < (img_h + 3.0 * cm):
             c.showPage()
             y = height - 2 * cm
-
         c.setFont("Helvetica-Bold", 10.5)
         c.drawString(x, y, caption)
         y -= 0.5 * cm
         c.drawImage(img, x, y - img_h, width=img_w, height=img_h, preserveAspectRatio=True, anchor="nw")
         y -= (img_h + 0.7 * cm)
 
-    h(title)
+    h("HoD Result Dashboard Report")
     line(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
 
     sh("1) KPI Summary (Teacher Insight)")
@@ -417,23 +332,19 @@ def generate_pdf_report(file_bytes, sheet_name, marks_col, grade_col, pass_mark,
         df, marks_col, grade_col, int(pass_mark), course_col, section_col, course_filter, section_filter
     )
 
-    pdf_buf = make_pdf(
-        kpi_df, percentiles_df, grade_dist, grade_stats, heaping_df,
-        fig1, fig2, fig3, fig4,
-        title="HoD Result Dashboard Report"
-    )
+    pdf_buf = make_pdf(kpi_df, percentiles_df, grade_dist, grade_stats, heaping_df, fig1, fig2, fig3, fig4)
     fname = f"dashboard_report__{sheet_name}__{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
     return (fname, pdf_buf.getvalue())
 
 
 # =============================
-# UI
+# UI (IMPORTANT: outputs order is correct)
 # =============================
 with gr.Blocks(title="HoD Result Dashboard") as demo:
-    gr.Markdown("## 📊 HoD Result Dashboard — Clean Teacher Insights (No Student Tables)")
+    gr.Markdown("## 📊 HoD Result Dashboard — Teacher Insights Only (No student tables)")
 
-    file_state = gr.State(None)
-    sheet_state = gr.State(None)
+    file_state = gr.State(None)   # bytes
+    sheet_state = gr.State(None)  # string
 
     with gr.Row():
         upload = gr.File(label="Upload Excel (.xlsx)", file_types=[".xlsx"])
@@ -458,12 +369,12 @@ with gr.Blocks(title="HoD Result Dashboard") as demo:
         kpi_table = gr.Dataframe(label="KPI Summary + Teacher Insight", interactive=False, wrap=True)
 
     with gr.Tab("Patterns"):
-        percentiles_table = gr.Dataframe(label="Percentiles (P10/P25/P50/P75/P90)", interactive=False, wrap=True)
+        percentiles_table = gr.Dataframe(label="Percentiles", interactive=False, wrap=True)
         heaping_table = gr.Dataframe(label="Mark Heaping (Top repeated marks)", interactive=False, wrap=True)
 
     with gr.Tab("Grades"):
         grade_dist_table = gr.Dataframe(label="Grade distribution", interactive=False, wrap=True)
-        grade_stats_table = gr.Dataframe(label="Grade → Marks mapping (min/max/mean/median)", interactive=False, wrap=True)
+        grade_stats_table = gr.Dataframe(label="Grade → Marks mapping", interactive=False, wrap=True)
 
     with gr.Tab("Charts"):
         with gr.Row():
@@ -477,46 +388,89 @@ with gr.Blocks(title="HoD Result Dashboard") as demo:
         pdf_btn = gr.Button("📄 Generate PDF Report")
         pdf_out = gr.File(label="Download PDF")
 
-    # Events
-    def _on_upload(file_obj):
-        sheet_dd_u, s_guess, m_guess, g_guess, c_col, sec_col, c_filter, sec_filter, fbytes, sh = load_excel(file_obj)
+    # ---- Callbacks
+    def on_upload(file_obj):
+        file_bytes = _read_file_bytes(file_obj)
+        xls = pd.ExcelFile(io.BytesIO(file_bytes), engine="openpyxl")
+        sheets = xls.sheet_names or []
+        if not sheets:
+            raise gr.Error("No sheets found.")
+
+        sheet0 = sheets[0]
+        df0 = pd.read_excel(io.BytesIO(file_bytes), sheet_name=sheet0, engine="openpyxl")
+        df0 = _drop_useless_cols(df0)
+
+        m_guess, g_guess, c_guess, s_guess = _guess_cols(df0)
+        cols = list(df0.columns)
+
+        # optional filter choices (based on guessed cols)
+        course_filter_update = gr.update(choices=["(all)"], value="(all)", visible=False, interactive=False)
+        section_filter_update = gr.update(choices=["(all)"], value="(all)", visible=False, interactive=False)
+
+        course_col_update = gr.update(choices=cols, value=(c_guess or cols[0]), visible=bool(c_guess), interactive=bool(c_guess))
+        section_col_update = gr.update(choices=cols, value=(s_guess or cols[0]), visible=bool(s_guess), interactive=bool(s_guess))
+
+        if c_guess and c_guess in df0.columns:
+            vals = ["(all)"] + sorted(df0[c_guess].astype(str).fillna("NA").unique().tolist())
+            course_filter_update = gr.update(choices=vals, value="(all)", visible=True, interactive=True)
+
+        if s_guess and s_guess in df0.columns:
+            vals = ["(all)"] + sorted(df0[s_guess].astype(str).fillna("NA").unique().tolist())
+            section_filter_update = gr.update(choices=vals, value="(all)", visible=True, interactive=True)
 
-        # we don't need student column anymore, so ignore s_guess
         return (
-            sheet_dd_u,
-            gr.Dropdown(choices=sheet_dd_u.choices, value=sheet_dd_u.value, interactive=True),
-            m_guess,
-            g_guess,
-            c_col,
-            sec_col,
-            c_filter,
-            sec_filter,
-            fbytes,
-            sh,
+            gr.update(choices=sheets, value=sheet0, interactive=True),     # sheet_dd
+            gr.update(choices=cols, value=m_guess, interactive=True),      # marks_col
+            gr.update(choices=cols, value=g_guess, interactive=True),      # grade_col
+            course_col_update,                                             # course_col
+            section_col_update,                                            # section_col
+            course_filter_update,                                          # course_filter
+            section_filter_update,                                         # section_filter
+            file_bytes,                                                    # file_state (BYTES!)
+            sheet0,                                                        # sheet_state (STRING!)
         )
 
     upload.change(
-        fn=load_excel,
+        fn=on_upload,
         inputs=[upload],
         outputs=[sheet_dd, marks_col, grade_col, course_col, section_col, course_filter, section_filter, file_state, sheet_state],
     )
 
+    def on_sheet_change(sheet_name, file_bytes, course_col_val, section_col_val):
+        if not file_bytes:
+            raise gr.Error("Upload Excel first.")
+        df = pd.read_excel(io.BytesIO(file_bytes), sheet_name=sheet_name, engine="openpyxl")
+        df = _drop_useless_cols(df)
+
+        # update filter dropdown choices for this sheet (if columns exist)
+        cf = gr.update(choices=["(all)"], value="(all)", visible=False, interactive=False)
+        sf = gr.update(choices=["(all)"], value="(all)", visible=False, interactive=False)
+
+        if course_col_val and course_col_val in df.columns:
+            vals = ["(all)"] + sorted(df[course_col_val].astype(str).fillna("NA").unique().tolist())
+            cf = gr.update(choices=vals, value="(all)", visible=True, interactive=True)
+
+        if section_col_val and section_col_val in df.columns:
+            vals = ["(all)"] + sorted(df[section_col_val].astype(str).fillna("NA").unique().tolist())
+            sf = gr.update(choices=vals, value="(all)", visible=True, interactive=True)
+
+        return cf, sf, sheet_name
+
     sheet_dd.change(
-        fn=read_sheet,
+        fn=on_sheet_change,
         inputs=[sheet_dd, file_state, course_col, section_col],
         outputs=[course_filter, section_filter, sheet_state],
     )
 
-    def on_refresh(file_bytes, sheet_name, m_col, g_col, pmark, c_col, sec_col, c_filter, sec_filter):
+    def on_refresh(file_bytes, sheet_name, m_col, g_col, pmark, c_col, s_col, c_filter, s_filter):
         if not file_bytes:
             raise gr.Error("Upload Excel first.")
         if not sheet_name:
             raise gr.Error("Select a sheet.")
-
         df = pd.read_excel(io.BytesIO(file_bytes), sheet_name=sheet_name, engine="openpyxl")
         df = _drop_useless_cols(df)
 
-        return compute_insights(df, m_col, g_col, int(pmark), c_col, sec_col, c_filter, sec_filter)
+        return compute_insights(df, m_col, g_col, int(pmark), c_col, s_col, c_filter, s_filter)
 
     analyze_btn.click(
         fn=on_refresh,
@@ -531,3 +485,4 @@ with gr.Blocks(title="HoD Result Dashboard") as demo:
     )
 
 demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)
+