Update app.py

app.py

@@ -2,7 +2,6 @@
 import os
 from datetime import date
 from typing import Dict, List
-
 import numpy as np
 import pandas as pd
 import plotly.graph_objects as go
@@ -14,19 +13,11 @@ st.set_page_config(page_title="Student Skill Radar", layout="wide")
 
 # ------------------- Constants -------------------
 SKILLS = [
-    "Problem-Solving",
-    "Critical Thinking",
-    "Analytical Reasoning",
-    "Adaptability",
-    "Continuous Learning",
-    "Creativity",
-    "Communication",
-    "Collaboration",
-    "Community Engagement",
-    "Emotional Intelligence",
-    "Ethical Decision-Making",
-    "Time Management",
-    "Tech Aptitude",
+    "Problem-Solving", "Critical Thinking", "Analytical Reasoning",
+    "Adaptability", "Continuous Learning", "Creativity",
+    "Communication", "Collaboration", "Community Engagement",
+    "Emotional Intelligence", "Ethical Decision-Making",
+    "Time Management", "Tech Aptitude"
 ]
 
 SKILL_GROUPS = {
@@ -43,10 +34,9 @@ SKILL_GROUPS = {
     "Emotional Intelligence, Ethical Decision Making": [
         "Emotional Intelligence", "Ethical Decision-Making"
     ],
-    "Tech Aptitude": ["Tech Aptitude"],
+    "Tech Aptitude": ["Tech Aptitude"]
 }
 
-# Map responses "source" → Likert stage
 SOURCE_TO_STAGE = {
     "onboarding_responses": "onboarding",
     "closing_responses": "closing",
@@ -72,22 +62,7 @@ def aggregate_groups_row(row: pd.Series) -> Dict[str, float]:
         for g, members in SKILL_GROUPS.items()
     }
 
-def summarize(records: List[dict], level: str = "student") -> pd.DataFrame:
-    df = pd.DataFrame(records) if records else pd.DataFrame()
-    if df.empty:
-        return df
-    if level == "student+source":
-        df["label"] = df["student"].astype(str) + " — " + df["source"].astype(str)
-    else:
-        df["label"] = df["student"].astype(str)
-    # groupby mean skips NaNs by default
-    return df.groupby("label", dropna=False)[SKILLS].mean().reset_index()
-
 def df_to_grouped(df_in: pd.DataFrame) -> pd.DataFrame:
-    """
-    Convert a base-skill df with a 'label' column into grouped columns so it
-    matches SKILL_GROUPS exactly (one row per label).
-    """
     if df_in.empty:
         return df_in
     rows = []
@@ -105,29 +80,15 @@ def plot_radar(df: pd.DataFrame, grouped: bool, title: str):
         return go.Figure()
 
     traces = []
-    if grouped:
-        labels = list(SKILL_GROUPS.keys())
-        for _, r in df.iterrows():
-            values = [0.0 if pd.isna(r.get(k)) else float(r.get(k)) for k in labels]
-            traces.append(go.Scatterpolar(
-                r=values + [values[0]],
-                theta=labels + [labels[0]],
-                name=r["label"],
-                fill="toself",
-            ))
-    else:
-        labels = SKILLS
-        for _, r in df.iterrows():
-            values = []
-            for k in SKILLS:
-                v = r.get(k, np.nan)
-                values.append(0.0 if pd.isna(v) else float(v))
-            traces.append(go.Scatterpolar(
-                r=values + [values[0]],
-                theta=labels + [labels[0]],
-                name=r["label"],
-                fill="toself",
-            ))
+    labels = list(SKILL_GROUPS.keys()) if grouped else SKILLS
+    for _, r in df.iterrows():
+        values = [0.0 if pd.isna(r.get(k)) else float(r.get(k)) for k in labels]
+        traces.append(go.Scatterpolar(
+            r=values + [values[0]],
+            theta=labels + [labels[0]],
+            name=r["label"],
+            fill="toself",
+        ))
 
     fig = go.Figure(traces)
     fig.update_layout(
@@ -135,21 +96,15 @@ def plot_radar(df: pd.DataFrame, grouped: bool, title: str):
         showlegend=True,
         polar=dict(
             radialaxis=dict(
-                autorange=False,
-                range=[0, 1],
-                tick0=0,
-                dtick=0.2,
-                ticks="outside",
-                showline=True,
-                showgrid=True,
-                visible=True,
+                autorange=False, range=[0, 1], tick0=0, dtick=0.2,
+                ticks="outside", showline=True, showgrid=True, visible=True
             )
         ),
         margin=dict(l=30, r=30, t=60, b=30),
     )
     return fig
 
-# ------------------- Mongo Access (secrets-only) -------------------
+# ------------------- Mongo -------------------
 def _get_secret(name: str) -> str | None:
     try:
         val = st.secrets.get(name)
@@ -165,40 +120,21 @@ def _build_uri(db_name: str | None) -> str | None:
     cluster = _get_secret("MONGO_CLUSTER")
     if not (user and pw and cluster):
         return None
-    user_q = quote_plus(user)
-    pw_q = quote_plus(pw)
-    db_path = f"/{db_name}" if db_name else ""
-    return (
-        f"mongodb+srv://{user_q}:{pw_q}@{cluster}{db_path}"
-        f"?retryWrites=true&w=majority&tls=true&tlsAllowInvalidCertificates=true"
-    )
+    return f"mongodb+srv://{quote_plus(user)}:{quote_plus(pw)}@{cluster}/{db_name}?retryWrites=true&w=majority&tls=true&tlsAllowInvalidCertificates=true"
 
 @st.cache_resource(show_spinner=False)
 def _client(uri: str):
     return MongoClient(uri, serverSelectionTimeoutMS=10000)
 
-# @st.cache_data(show_spinner=False)
 def mongo_distinct(uri: str, db: str, coll: str, field: str) -> List[str]:
     if not uri:
         return []
     try:
-        c = _client(uri)
-        vals = c[db][coll].distinct(field)
-        return sorted([v for v in vals if isinstance(v, str) and v.strip()])
+        return sorted([v for v in _client(uri)[db][coll].distinct(field) if isinstance(v, str) and v.strip()])
     except Exception:
         return []
 
-# @st.cache_data(show_spinner=False)
-def mongo_records(
-    uri: str,
-    db: str,
-    coll: str,
-    student: str | None,
-    source: str | None,
-    start: str | None,
-    end: str | None,
-) -> List[dict]:
-    """Return flat rows with one column per skill; missing skills -> NaN (ignored in means)."""
+def mongo_records(uri: str, db: str, coll: str, student: str | None, source: str | None, start: str | None, end: str | None) -> List[dict]:
     if not uri:
         return []
     q = {}
@@ -208,57 +144,32 @@ def mongo_records(
         q["source"] = source
     if start or end:
         q["date"] = {}
-        if start:
-            q["date"]["$gte"] = start
-        if end:
-            q["date"]["$lte"] = end
+        if start: q["date"]["$gte"] = start
+        if end: q["date"]["$lte"] = end
     try:
-        c = _client(uri)
-        proj = {"_id": 0, "student": 1, "source": 1, "date": 1, "skills": 1}
-        docs = list(c[db][coll].find(q, proj))
+        docs = list(_client(uri)[db][coll].find(q, {"_id": 0, "student": 1, "source": 1, "skills": 1}))
         rows = []
         for d in docs:
-            base = {
-                "student": str(d.get("student", "")),
-                "source": str(d.get("source", "")),
-                "date": str(d.get("date", "")),
-            }
-            sd = d.get("skills") or {}
+            base = {"student": str(d.get("student", "")), "source": str(d.get("source", ""))}
             for k in SKILLS:
-                base[k] = to_01_or_nan(sd.get(k, np.nan))
+                base[k] = to_01_or_nan((d.get("skills") or {}).get(k, np.nan))
             rows.append(base)
         return rows
     except Exception:
         return []
 
-# ---------- Likert helpers (fetch + normalize 0..1) ----------
+# ---------- Likert helpers ----------
 def _norm_01(v):
-    if v is None:
-        return None
     try:
-        v = float(v)
+        return max(0.0, min(1.0, float(v) / 5.0 if float(v) > 1 else float(v)))
     except Exception:
         return None
-    return max(0.0, min(1.0, v / 5.0 if v > 1.0 else v))
-
-def mongo_get_likert_grouped(
-    uri: str,
-    db: str,
-    coll: str,
-    student: str,
-    stage: str
-) -> dict:
-    """
-    Returns {group_label: score_0_1} from likert_summaries for a student+stage, or {} if missing.
-    """
+
+def mongo_get_likert_grouped(uri: str, db: str, coll: str, student: str, stage: str) -> dict:
     if not (uri and student and stage):
         return {}
     try:
-        c = _client(uri)
-        doc = c[db][coll].find_one(
-            {"student_name": student, "stage": stage},
-            {"_id": 0, "average_skill_scores": 1}
-        )
+        doc = _client(uri)[db][coll].find_one({"student_name": student, "stage": stage}, {"_id": 0, "average_skill_scores": 1})
         avg = (doc or {}).get("average_skill_scores") or {}
         return {g: _norm_01(avg.get(g)) for g in SKILL_GROUPS.keys()}
     except Exception:
@@ -268,107 +179,73 @@ def mongo_get_likert_grouped(
 st.title("📊 Student Skill Radar")
 
 with st.sidebar:
-    st.subheader("MongoDB Settings")
     db_name = st.text_input("Database name", value="student_skills")
     coll_name = st.text_input("Collection name", value="responses_IFE_2025")
     summaries_coll = st.text_input("Likert summaries collection", value="likert_summaries_IFE_2025")
 
     mongo_uri = _build_uri(db_name)
-
-    if not mongo_uri:
-        st.warning("Missing MONGO_USER, MONGO_PASS, or MONGO_CLUSTER in secrets/env.")
-    else:
-        try:
-            _client(mongo_uri).admin.command("ping")
-            st.success("Connected via secrets ✅")
-        except Exception as e:
-            st.error(f"Mongo connection failed: {e}")
-
-    # Filters
     students = ["(All)"] + (mongo_distinct(mongo_uri, db_name, coll_name, "student") if mongo_uri else [])
     sources = ["(All)"] + (mongo_distinct(mongo_uri, db_name, coll_name, "source") if mongo_uri else [])
 
     student_choice = st.selectbox("Select student", students)
     source_choice = st.selectbox("Select source/week", sources)
-
-    c1, c2 = st.columns(2)
-    start_dt = c1.date_input("Start date", value=None)
-    end_dt = c2.date_input("End date", value=None)
-
-    agg_level = st.selectbox("Aggregation level", ["student", "student+source"], index=0)
-    grouped = st.toggle("Grouped skills (skill clusters)", value=True)
+    start_dt = st.date_input("Start date", value=None)
+    end_dt = st.date_input("End date", value=None)
+    grouped = st.toggle("Grouped skills", value=True)
     overlay_sources = st.toggle("Overlay all sources when '(All)' selected", value=False)
     chart_title = st.text_input("Chart title", value="")
 
-# Convert dates to strings (YYYY-MM-DD)
 start_str = start_dt.strftime("%Y-%m-%d") if isinstance(start_dt, date) else None
 end_str = end_dt.strftime("%Y-%m-%d") if isinstance(end_dt, date) else None
 
-# ------------------- Fetch + aggregate -------------------
+# ------------------- Fetch + merge -------------------
 records = mongo_records(mongo_uri, db_name, coll_name, student_choice, source_choice, start_str, end_str) if mongo_uri else []
 df_raw = pd.DataFrame(records) if records else pd.DataFrame()
 
-# Build label per agg_level; aggregate means across rows
 if not df_raw.empty:
-    if agg_level == "student+source":
-        df_raw["label"] = df_raw["student"].astype(str) + " — " + df_raw["source"].astype(str)
-    else:
-        df_raw["label"] = df_raw["student"].astype(str)
+    df_raw["label"] = df_raw["student"].astype(str) + " — " + df_raw["source"].astype(str)
     df_resp = df_raw.groupby("label", dropna=False)[SKILLS].mean().reset_index()
+    if grouped:
+        df_resp = df_to_grouped(df_resp)
 else:
     df_resp = pd.DataFrame()
 
-# If grouped view, convert responses to grouped columns
-if grouped and not df_resp.empty:
-    df_resp = df_to_grouped(df_resp)
-
-# Merge in Likert grouped scores (average) for onboarding/closing sources
-df_final = df_resp.copy()
-if grouped and not df_final.empty and agg_level == "student+source" and summaries_coll:
+# Merge Likert scores
+if grouped and not df_resp.empty and summaries_coll:
     merged_rows = []
-    for _, r in df_final.iterrows():
+    for _, r in df_resp.iterrows():
         label = str(r["label"])
-        # Expect "Student — source"
-        if " — " in label:
-            student, src = label.split(" — ", 1)
-            stage = SOURCE_TO_STAGE.get(src.strip())
-        else:
-            student, src, stage = label, None, None
-
-        if stage in ("onboarding", "closing") and mongo_uri:
-            likert = mongo_get_likert_grouped(mongo_uri, db_name, summaries_coll, student=student, stage=stage)
-            out = {"label": label}
-            for glabel in SKILL_GROUPS.keys():
-                resp_val = r.get(glabel, np.nan)
-                resp_val = None if pd.isna(resp_val) else float(resp_val)
-                likert_val = likert.get(glabel, None)
-                if resp_val is not None and likert_val is not None:
-                    out[glabel] = (resp_val + likert_val) / 2.0  # merge rule
-                elif resp_val is not None:
-                    out[glabel] = resp_val
-                elif likert_val is not None:
-                    out[glabel] = likert_val
-                else:
-                    out[glabel] = np.nan
-            merged_rows.append(out)
-        else:
-            merged_rows.append(dict(r))
-
+        student, stage = label.split(" — ", 1) if " — " in label else (label, None)
+        stage = SOURCE_TO_STAGE.get(stage.strip()) if stage else None
+        likert = mongo_get_likert_grouped(mongo_uri, db_name, summaries_coll, student.strip(), stage) if stage in ("onboarding", "closing") else {}
+        out = {"label": label}
+        for g in SKILL_GROUPS.keys():
+            resp_val = None if pd.isna(r.get(g)) else float(r.get(g))
+            likert_val = likert.get(g, None)
+            if resp_val is not None and likert_val is not None:
+                out[g] = (resp_val + likert_val) / 2.0
+            elif resp_val is not None:
+                out[g] = resp_val
+            elif likert_val is not None:
+                out[g] = likert_val
+            else:
+                out[g] = np.nan
+        merged_rows.append(out)
     df_final = pd.DataFrame(merged_rows, columns=["label"] + list(SKILL_GROUPS.keys()))
 else:
     df_final = df_resp
 
-# If overlay is OFF and source is (All), collapse to one trace per student by averaging grouped vals
-if grouped and not df_final.empty and source_choice == "(All)" and not overlay_sources:
-    df_final["_student"] = df_final["label"].apply(lambda s: s.split(" — ", 1)[0] if " — " in str(s) else str(s))
-    group_cols = list(SKILL_GROUPS.keys())
-    df_final = df_final.groupby("_student", dropna=False)[group_cols].mean().reset_index()
+# Overlay mode
+if grouped and not df_final.empty and source_choice == "(All)" and overlay_sources:
+    df_final["_student"] = df_final["label"].apply(lambda s: s.split(" — ", 1)[0])
+    df_final = df_final.groupby("_student", dropna=False)[list(SKILL_GROUPS.keys())].mean().reset_index()
     df_final = df_final.rename(columns={"_student": "label"})
 
 # ------------------- Output -------------------
-fig = plot_radar(df_final if not df_final.empty else pd.DataFrame(), grouped, chart_title)
+fig = plot_radar(df_final, grouped, chart_title)
 st.plotly_chart(fig, use_container_width=True)
-st.caption(f"{len(df_final)} line(s) aggregated." if not df_final.empty else "No data. Adjust filters or check Mongo connection.")
+st.caption(f"{len(df_final)} line(s) aggregated." if not df_final.empty else "No data.")
+
 
 # # app.py — Student Skill Radar (MongoDB, secrets-based, no CSV)
 # import os