Update app.py

app.py

@@ -112,6 +112,54 @@ def plot_radar(df: pd.DataFrame, grouped: bool, title: str, avg_label: str = Non
         margin=dict(l=30, r=30, t=60, b=30),
     )
     return fig
+    
+def _vector_from_row(row: pd.Series, cols: list[str]) -> dict:
+    return {k: (None if pd.isna(row.get(k)) else float(row.get(k))) for k in cols}
+
+def _percent_change(new: float | None, old: float | None) -> float | None:
+    if new is None or old is None:
+        return None
+    if old == 0:
+        return None  # avoid div-by-zero; you can choose to show 100% if new>0
+    return (new - old) / old * 100.0
+
+def _merge_resp_and_likert_vector(resp_vec: dict, likert_grouped_vec: dict | None, grouped: bool, SKILL_TO_GROUPS: dict[str, list[str]], SKILL_GROUPS: dict[str, list[str]]) -> dict:
+    """
+    Returns a merged vector:
+    - If grouped: keys are group labels
+    - If ungrouped: keys are per-skill; Likert (group) is projected to skills by averaging groups a skill belongs to
+    """
+    if likert_grouped_vec is None:
+        return resp_vec
+
+    if grouped:
+        out = {}
+        for g in SKILL_GROUPS.keys():
+            rv = resp_vec.get(g, None)
+            lv = likert_grouped_vec.get(g, None)
+            if rv is not None and lv is not None:
+                out[g] = (rv + lv) / 2.0
+            elif rv is not None:
+                out[g] = rv
+            else:
+                out[g] = lv
+        return out
+    else:
+        # project group likert to each skill
+        out = {}
+        for s in resp_vec.keys():
+            rv = resp_vec.get(s, None)
+            groups = SKILL_TO_GROUPS.get(s, [])
+            lik_vals = [likert_grouped_vec.get(g) for g in groups if likert_grouped_vec.get(g) is not None]
+            lv = float(np.mean(lik_vals)) if lik_vals else None
+            if rv is not None and lv is not None:
+                out[s] = (rv + lv) / 2.0
+            elif rv is not None:
+                out[s] = rv
+            else:
+                out[s] = lv
+        return out
+
 # ------------------- Mongo -------------------
 def _get_secret(name: str) -> str | None:
     try:
@@ -343,6 +391,120 @@ if not df_final.empty and source_choice == "(All)":
 # ------------------- Output -------------------
 # fig = plot_radar(df_final, grouped, chart_title)
 # st.plotly_chart(fig, use_container_width=True)
+# ============== Build per-stage vectors for comparisons ==============
+# Columns to use based on mode
+COLS = list(SKILL_GROUPS.keys()) if grouped else SKILLS
+
+# Helper to extract the mean vector for (student, source) from df_resp/df_final
+def _mean_vector_for(student: str | None, source: str | None, use_merged: bool) -> dict:
+    """
+    use_merged=True -> read from df_final (after Likert merge)
+    use_merged=False -> read from df_resp (responses-only)
+    """
+    df_base = df_final if use_merged else df_resp
+    if df_base.empty:
+        return {k: None for k in COLS}
+
+    if student and source:
+        label = f"{student} — {source}"
+        sub = df_base[df_base["label"] == label]
+    elif student and source is None:
+        # combined sources row (when overlay OFF)
+        sub = df_base[df_base["label"] == student]
+    else:
+        # cohort average across all rows in df_base
+        sub = df_base
+
+    if sub.empty:
+        return {k: None for k in COLS}
+    means = sub[COLS].mean(numeric_only=True)
+    return {k: (None if pd.isna(means.get(k)) else float(means.get(k))) for k in COLS}
+
+# Build mapping skill->groups (you already used this in the Likert merge)
+SKILL_TO_GROUPS = {s: [g for g, members in SKILL_GROUPS.items() if s in members] for s in SKILLS}
+
+def _likert_grouped_for(student: str, stage: str) -> dict | None:
+    if stage not in ("onboarding", "closing"):
+        return None
+    lg = mongo_get_likert_grouped(mongo_uri, db_name, summaries_coll, student, stage)
+    return lg if lg else None
+
+def _stage_vector(student: str | None, stage: str) -> dict:
+    # Which sources make up this stage?
+    if stage == "onboarding":
+        srcs = ["onboarding_responses"]
+    elif stage == "closing":
+        srcs = ["closing_responses"]
+    elif stage == "combined_weeks":
+        srcs = ["week_2_responses", "week_3_responses", "closing_responses"]
+    else:
+        srcs = []
+
+    # Response-only mean across those sources
+    if not df_resp.empty:
+        if student and source_choice == "(All)":
+            # we may have aggregated to one row per student; compute from df_raw instead
+            # build per-source labels then average
+            rows = []
+            for s in srcs:
+                lbl = f"{student} — {s}"
+                sub = df_resp[df_resp["label"] == lbl]
+                if not sub.empty:
+                    rows.append(sub[COLS].mean(numeric_only=True))
+            if rows:
+                m = pd.concat(rows, axis=1).mean(axis=1)
+                resp_vec = {k: (None if pd.isna(m.get(k)) else float(m.get(k))) for k in COLS}
+            else:
+                resp_vec = {k: None for k in COLS}
+        elif student and source_choice != "(All)":
+            # if the UI is filtered to a specific source, ignore that and recompute from df_resp
+            rows = []
+            for s in srcs:
+                lbl = f"{student} — {s}"
+                sub = df_resp[df_resp["label"] == lbl]
+                if not sub.empty:
+                    rows.append(sub[COLS].mean(numeric_only=True))
+            if rows:
+                m = pd.concat(rows, axis=1).mean(axis=1)
+                resp_vec = {k: (None if pd.isna(m.get(k)) else float(m.get(k))) for k in COLS}
+            else:
+                resp_vec = {k: None for k in COLS}
+        else:
+            # cohort: average across all matching sources
+            sub = df_resp[df_resp["label"].str.contains(" — ", na=False)]
+            sub = sub[sub["label"].str.split(" — ").str[1].isin(srcs)]
+            if not sub.empty:
+                m = sub[COLS].mean(numeric_only=True)
+                resp_vec = {k: (None if pd.isna(m.get(k)) else float(m.get(k))) for k in COLS}
+            else:
+                resp_vec = {k: None for k in COLS}
+    else:
+        resp_vec = {k: None for k in COLS}
+
+    # Merge in Likert for onboarding/closing (projected to skills if ungrouped)
+    if student:
+        likert_g = _likert_grouped_for(student, "onboarding" if "onboarding_responses" in srcs else ("closing" if "closing_responses" in srcs and len(srcs)==1 else None))
+    else:
+        likert_g = None  # no cohort Likert
+
+    merged = _merge_resp_and_likert_vector(resp_vec, likert_g, grouped, SKILL_TO_GROUPS, SKILL_GROUPS)
+    return merged
+
+# Build the vectors we need
+if student_choice != "(All)":
+    vec_onb = _stage_vector(student_choice, "onboarding")
+    vec_cls = _stage_vector(student_choice, "closing")
+    vec_combo = _stage_vector(student_choice, "combined_weeks")
+else:
+    # Cohort-wide comparison
+    vec_onb = _stage_vector(None, "onboarding")
+    vec_cls = _stage_vector(None, "closing")
+    vec_combo = _stage_vector(None, "combined_weeks")
+
+# Compute % deltas
+pct_onb_to_cls = {k: _percent_change(vec_cls.get(k), vec_onb.get(k)) for k in COLS}
+pct_onb_to_combo = {k: _percent_change(vec_combo.get(k), vec_onb.get(k)) for k in COLS}
+
 df_plot = df_final.copy()
 avg_label = None
 
@@ -662,6 +824,36 @@ with tab_analyses:
             if idx:
                 st.caption("Available analyses:")
                 st.write(", ".join(sorted({name.title() for name in idx.keys()})))
+tab_compare, = st.tabs(["📊 Comparisons"])
+
+with tab_compare:
+    st.subheader("Onboarding vs Closing — % Change")
+    df1 = pd.DataFrame({
+        "Dimension": COLS,
+        "Onboarding": [vec_onb.get(k) for k in COLS],
+        "Closing": [vec_cls.get(k) for k in COLS],
+        "% Change": [pct_onb_to_cls.get(k) for k in COLS],
+    })
+    st.dataframe(df1.style.format({"Onboarding": "{:.2f}", "Closing": "{:.2f}", "% Change": "{:+.1f}%"}), use_container_width=True)
+
+    st.subheader("Onboarding vs (Week2+Week3+Closing) — % Change")
+    df2 = pd.DataFrame({
+        "Dimension": COLS,
+        "Onboarding": [vec_onb.get(k) for k in COLS],
+        "Weeks 2+3+Closing (combined)": [vec_combo.get(k) for k in COLS],
+        "% Change": [pct_onb_to_combo.get(k) for k in COLS],
+    })
+    st.dataframe(df2.style.format({"Onboarding": "{:.2f}", "Weeks 2+3+Closing (combined)": "{:.2f}", "% Change": "{:+.1f}%"}), use_container_width=True)
+
+    # Optional bar chart: % change Onboarding -> Closing
+    try:
+        fig_delta = go.Figure()
+        fig_delta.add_bar(x=COLS, y=[pct_onb_to_cls.get(k) if pct_onb_to_cls.get(k) is not None else 0 for k in COLS], name="%Δ Onb→Closing")
+        fig_delta.update_layout(title="% Change: Onboarding → Closing", xaxis_title="Dimension", yaxis_title="% change", margin=dict(l=20, r=20, t=50, b=20))
+        st.plotly_chart(fig_delta, use_container_width=True)
+    except Exception:
+        pass
+
 
 # # app.py — Student Skill Radar (MongoDB, secrets-based, no CSV)
 # import os