Update app.py

app.py

@@ -1,8 +1,7 @@
-# app.py
+# app.py — Streamlit radar charts from MongoDB (scores 0–1)
 import os
 import json
-import math
-from datetime import datetime
+from datetime import date
 from typing import Dict, List
 
 import numpy as np
@@ -10,7 +9,6 @@ import pandas as pd
 import plotly.graph_objects as go
 import streamlit as st
 from pymongo import MongoClient
-from urllib.parse import quote_plus
 
 st.set_page_config(page_title="Student Skill Radar", layout="wide")
 
@@ -33,24 +31,17 @@ SKILLS = [
 
 SKILL_GROUPS = {
     "Problem-Solving, Critical Thinking, Analytical Reasoning": [
-        "Problem-Solving",
-        "Critical Thinking",
-        "Analytical Reasoning",
+        "Problem-Solving", "Critical Thinking", "Analytical Reasoning"
     ],
     "Adaptability, Continuous Learning, Creativity": [
-        "Adaptability",
-        "Continuous Learning",
-        "Creativity",
+        "Adaptability", "Continuous Learning", "Creativity"
     ],
     "Time Management": ["Time Management"],
     "Communication, Teamwork, Collaboration, Community Engagement": [
-        "Communication",
-        "Collaboration",
-        "Community Engagement",
+        "Communication", "Collaboration", "Community Engagement"
     ],
     "Emotional Intelligence, Ethical Decision Making": [
-        "Emotional Intelligence",
-        "Ethical Decision-Making",
+        "Emotional Intelligence", "Ethical Decision-Making"
     ],
     "Tech Aptitude": ["Tech Aptitude"],
 }
@@ -65,16 +56,21 @@ def to_frame(records: List[dict]) -> pd.DataFrame:
     if not records:
         return pd.DataFrame()
     df = pd.DataFrame(records)
-    # Expand skills into columns
-    skill_df = pd.json_normalize(df["skills"]).reindex(columns=SKILLS)
+    # Expand skills into columns in SKILLS order
+    skill_df = pd.json_normalize(df.get("skills", {})).reindex(columns=SKILLS)
     for k in SKILLS:
         if k not in skill_df:
             skill_df[k] = 0.0
-    df = pd.concat([df.drop(columns=["skills"]), skill_df], axis=1)
+    df = pd.concat([df.drop(columns=["skills"], errors="ignore"), skill_df], axis=1)
     return df
 
 
-def summarize_records(records: List[dict], level: str = "student") -> pd.DataFrame:
+def aggregate_groups_row(row: pd.Series) -> Dict[str, float]:
+    return {g: safe_mean([float(row.get(s, 0.0)) for s in members]) for g, members in SKILL_GROUPS.items()}
+
+
+def summarize(records: List[dict], level: str = "student") -> pd.DataFrame:
+    """Average per label over SKILLS; level in {student, student+source}."""
     df = to_frame(records)
     if df.empty:
         return df
@@ -85,14 +81,7 @@ def summarize_records(records: List[dict], level: str = "student") -> pd.DataFra
     return df.groupby("label")[SKILLS].mean().reset_index()
 
 
-def aggregate_groups(row: pd.Series) -> Dict[str, float]:
-    out = {}
-    for group, members in SKILL_GROUPS.items():
-        out[group] = safe_mean([float(row.get(m, 0.0)) for m in members])
-    return out
-
-
-def polar_radar(df: pd.DataFrame, grouped: bool, title: str):
+def plot_radar(df: pd.DataFrame, grouped: bool, title: str):
     if df.empty:
         return go.Figure()
 
@@ -100,10 +89,15 @@ def polar_radar(df: pd.DataFrame, grouped: bool, title: str):
         labels = list(SKILL_GROUPS.keys())
         traces = []
         for _, r in df.iterrows():
-            grp = aggregate_groups(r)
+            grp = aggregate_groups_row(r)
             values = [grp[k] for k in labels]
             traces.append(
-                go.Scatterpolar(r=values + [values[0]], theta=labels + [labels[0]], name=r["label"], fill="toself")
+                go.Scatterpolar(
+                    r=values + [values[0]],
+                    theta=labels + [labels[0]],
+                    name=r["label"],
+                    fill="toself",
+                )
             )
     else:
         labels = SKILLS
@@ -111,7 +105,12 @@ def polar_radar(df: pd.DataFrame, grouped: bool, title: str):
         for _, r in df.iterrows():
             values = [float(r.get(k, 0.0)) for k in SKILLS]
             traces.append(
-                go.Scatterpolar(r=values + [values[0]], theta=labels + [labels[0]], name=r["label"], fill="toself")
+                go.Scatterpolar(
+                    r=values + [values[0]],
+                    theta=labels + [labels[0]],
+                    name=r["label"],
+                    fill="toself",
+                )
             )
 
     fig = go.Figure(traces)
@@ -124,39 +123,40 @@ def polar_radar(df: pd.DataFrame, grouped: bool, title: str):
     return fig
 
 
-# ------------------- Data Loaders -------------------
+# ------------------- Mongo Access -------------------
 @st.cache_data(show_spinner=False)
-def parse_summary_files(files) -> pd.DataFrame:
-    """Uploads: list of per-student summary JSON files"""
-    rows = []
-    for f in files or []:
-        try:
-            data = json.loads(f.read().decode("utf-8"))
-        except Exception:
-            f.seek(0)
-            data = json.load(f)
-        name = data.get("Name") or data.get("Student") or "Unknown"
-        scores = data.get("Average Skill Scores") or {}
-        row = {"label": name}
-        for k in SKILLS:
-            row[k] = float(scores.get(k, 0.0))
-        rows.append(row)
-    return pd.DataFrame(rows)
+def _client(uri: str):
+    return MongoClient(uri, serverSelectionTimeoutMS=10000)
+
+
+def get_mongo_uri(db_name: str | None = None) -> str | None:
+    """Priority: st.secrets.MONGO_URI -> env MONGO_URI -> compose from MONGO_USER/PASS/CLUSTER."""
+    uri = st.secrets.get("MONGO_URI") if hasattr(st, "secrets") else None
+    uri = uri or os.getenv("MONGO_URI")
+    if uri:
+        return uri
+    user = os.getenv("MONGO_USER")
+    pw = os.getenv("MONGO_PASS")
+    cluster = os.getenv("MONGO_CLUSTER")
+    if user and pw and cluster:
+        # allow db_name in path for SRV
+        db_path = f"/{db_name}" if db_name else ""
+        return f"mongodb+srv://{user}:{pw}@{cluster}{db_path}?retryWrites=true&w=majority"
+    return None
 
 
 @st.cache_data(show_spinner=False)
-def mongo_records(db_name: str, coll_name: str, student: str | None, source: str | None, start: str | None, end: str | None) -> List[dict]:
-    if not (db_name and coll_name):
+def mongo_distinct(uri: str, db: str, coll: str, field: str) -> List[str]:
+    try:
+        c = _client(uri)
+        vals = c[db][coll].distinct(field)
+        return sorted([v for v in vals if isinstance(v, str) and v.strip()])
+    except Exception:
         return []
-    user = quote_plus(os.getenv("MONGO_USER"))
-    password = quote_plus(os.getenv("MONGO_PASS"))
-    cluster = os.getenv("MONGO_CLUSTER")
-    # db_name = os.environ.get("MONGO_DB", "grant_docs")
-    mongo_uri = f"mongodb+srv://{user}:{password}@{cluster}/{db_name}?retryWrites=true&w=majority&tls=true&tlsAllowInvalidCertificates=true"
-    client = MongoClient(mongo_uri, tls=True, tlsAllowInvalidCertificates=True, serverSelectionTimeoutMS=20000)
-    # client = MongoClient(uri, serverSelectionTimeoutMS=6000)
-    coll = client[db_name][coll_name]
 
+
+@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]:
     q = {}
     if student and student != "(All)":
         q["student"] = student
@@ -168,118 +168,356 @@ def mongo_records(db_name: str, coll_name: str, student: str | None, source: str
             q["date"]["$gte"] = start
         if end:
             q["date"]["$lte"] = end
-
-    cur = coll.find(q, {"_id": 0, "student": 1, "source": 1, "date": 1, "skills": 1})
-    recs = []
-    for r in cur:
-        r.setdefault("skills", {})
-        r["skills"] = {k: float(r["skills"].get(k, 0.0)) for k in SKILLS}
-        recs.append(r)
-    return recs
-
-
-@st.cache_data(show_spinner=False)
-def mongo_distinct( db_name: str, coll_name: str, field: str) -> List[str]:
-    if not (db_name and coll_name):
-        return []
     try:
-        user = quote_plus(os.getenv("MONGO_USER"))
-        password = quote_plus(os.getenv("MONGO_PASS"))
-        cluster = os.getenv("MONGO_CLUSTER")
-        mongo_uri = f"mongodb+srv://{user}:{password}@{cluster}/{db_name}?retryWrites=true&w=majority&tls=true&tlsAllowInvalidCertificates=true"
-        client = MongoClient(mongo_uri, tls=True, tlsAllowInvalidCertificates=True, serverSelectionTimeoutMS=20000)
-        # client = MongoClient(uri, serverSelectionTimeoutMS=6000)
-        coll = client[db_name][coll_name]
-        vals = coll.distinct(field)
-        return sorted([v for v in vals if isinstance(v, str) and v.strip()])
+        c = _client(uri)
+        proj = {"_id": 0, "student": 1, "source": 1, "date": 1, "skills": 1}
+        out = list(c[db][coll].find(q, proj))
+        # normalize scores to floats; default 0.0
+        for r in out:
+            r.setdefault("skills", {})
+            r["skills"] = {k: float(r["skills"].get(k, 0.0)) for k in SKILLS}
+        return out
     except Exception:
         return []
 
 
 # ------------------- UI -------------------
-st.title("Student Skill Radar — Streamlit")
+st.title("📊 Student Skill Radar — MongoDB only")
 
 with st.sidebar:
-    st.subheader("Data Source")
-    data_source = st.radio("Select source", ["Upload JSON summaries", "MongoDB"], index=0)
-    use_groups = st.toggle("Grouped skills (skill clusters)", value=False)
-    agg_level = st.selectbox("Aggregation level", ["student", "student+source"], index=0, help="How to average records before plotting")
+    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")
+
+    # URI handling
+    detected_uri = get_mongo_uri(db_name)
+    uri_override = st.text_input("Override MONGO_URI (optional)", type="password")
+    mongo_uri = uri_override.strip() or (detected_uri or "")
+    if not mongo_uri:
+        st.warning("No Mongo URI found. Set MONGO_URI (or MONGO_USER/PASS/CLUSTER) in Space secrets, or paste an override.")
+
+    # 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=False)
     chart_title = st.text_input("Chart title", value="")
 
-if data_source == "Upload JSON summaries":
-    files = st.file_uploader("Upload 1+ summary JSON files", type=["json"], accept_multiple_files=True)
-    df = parse_summary_files(files)
-
-    # Student dropdown based on uploaded files
-    labels = ["(All)"] + (sorted(df["label"].unique().tolist()) if not df.empty else [])
-    selected = st.sidebar.selectbox("Select student", labels)
-
-    if selected != "(All)" and not df.empty:
-        df = df[df["label"] == selected]
-
-else:
-    st.sidebar.subheader("MongoDB Settings")
-    # default_uri = st.secrets.get("MONGO_URI", "")
-    # mongo_uri = st.sidebar.text_input("MongoDB URI", value=default_uri, type="password")
-    db_name = st.sidebar.text_input("Database name", value="grant_docs")
-    coll_name = st.sidebar.text_input("Collection name", value="doc_chunks")
-
-    # Dynamic dropdowns from MongoDB
-    students = ["(All)"] + mongo_distinct(db_name, coll_name, "student")
-    sources = ["(All)"] + mongo_distinct(db_name, coll_name, "source")
-
-    student_choice = st.sidebar.selectbox("Select student", students)
-    source_choice = st.sidebar.selectbox("Select source/week", sources)
-
-    c1, c2 = st.sidebar.columns(2)
-    start_date = c1.text_input("Start date (YYYY-MM-DD)", value="")
-    end_date = c2.text_input("End date (YYYY-MM-DD)", value="")
-
-    recs = mongo_records(db_name, coll_name, student_choice, source_choice, start_date or None, end_date or None)
-    df_raw = to_frame(recs)
-    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 = df_raw.groupby("label")[SKILLS].mean().reset_index()
-    else:
-        df = pd.DataFrame()
+# 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
+records = mongo_records(mongo_uri, db_name, coll_name, student_choice, source_choice, start_str, end_str) if mongo_uri else []
+
+df = summarize(records, level=agg_level) if records else pd.DataFrame()
 
 # ------------------- Output -------------------
 left, right = st.columns([2, 1])
 
 with left:
-    fig = polar_radar(df if not df.empty else pd.DataFrame(), use_groups, chart_title)
+    fig = plot_radar(df, grouped, chart_title)
     st.plotly_chart(fig, use_container_width=True)
 
 with right:
-    st.subheader("Averaged Scores")
+    st.subheader("Averaged Scores (0–1)")
     if df.empty:
-        st.info("No data yet. Upload summaries or configure MongoDB, then select a student.")
+        st.info("No data. Adjust filters or check Mongo connection.")
     else:
         st.dataframe(df, use_container_width=True, height=450)
-        # CSV download
         csv = df.to_csv(index=False).encode("utf-8")
         st.download_button("Download CSV", data=csv, file_name="skill_scores.csv", mime="text/csv")
 
-# # --------------- README (for reference in Space) ---------------
-# """
-# To deploy on Hugging Face Spaces:
-# 1) Create a new Space → SDK: Streamlit → Python.
-# 2) Add `app.py` and `requirements.txt` below.
-# 3) (Optional) Add a Secret named `MONGO_URI` for your Mongo connection.
-
-# Accepted Schemas
-# - Summary JSON (per student):
-#   {
-#     "Name": "Student Name",
-#     "Average Skill Scores": {"Problem-Solving": 0.6, ...}
-#   }
-# - MongoDB record (per response):
-#   {
-#     "uid": "...", "student": "...", "source": "week_2", "date": "YYYY-MM-DD",
-#     "prompt": "...", "answer": "...",
-#     "skills": { "Problem-Solving": 0.6, "Collaboration": 0.7, ... }
-#   }
-# """
+# # app.py
+# import os
+# import json
+# import math
+# from datetime import datetime
+# from typing import Dict, List
+
+# import numpy as np
+# import pandas as pd
+# import plotly.graph_objects as go
+# import streamlit as st
+# from pymongo import MongoClient
+# from urllib.parse import quote_plus
+
+# 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",
+# ]
+
+# SKILL_GROUPS = {
+#     "Problem-Solving, Critical Thinking, Analytical Reasoning": [
+#         "Problem-Solving",
+#         "Critical Thinking",
+#         "Analytical Reasoning",
+#     ],
+#     "Adaptability, Continuous Learning, Creativity": [
+#         "Adaptability",
+#         "Continuous Learning",
+#         "Creativity",
+#     ],
+#     "Time Management": ["Time Management"],
+#     "Communication, Teamwork, Collaboration, Community Engagement": [
+#         "Communication",
+#         "Collaboration",
+#         "Community Engagement",
+#     ],
+#     "Emotional Intelligence, Ethical Decision Making": [
+#         "Emotional Intelligence",
+#         "Ethical Decision-Making",
+#     ],
+#     "Tech Aptitude": ["Tech Aptitude"],
+# }
+
+# # ------------------- Helpers -------------------
+# def safe_mean(vals):
+#     vals = [v for v in vals if v is not None]
+#     return float(np.mean(vals)) if vals else 0.0
+
+
+# def to_frame(records: List[dict]) -> pd.DataFrame:
+#     if not records:
+#         return pd.DataFrame()
+#     df = pd.DataFrame(records)
+#     # Expand skills into columns
+#     skill_df = pd.json_normalize(df["skills"]).reindex(columns=SKILLS)
+#     for k in SKILLS:
+#         if k not in skill_df:
+#             skill_df[k] = 0.0
+#     df = pd.concat([df.drop(columns=["skills"]), skill_df], axis=1)
+#     return df
+
+
+# def summarize_records(records: List[dict], level: str = "student") -> pd.DataFrame:
+#     df = to_frame(records)
+#     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)
+#     return df.groupby("label")[SKILLS].mean().reset_index()
+
+
+# def aggregate_groups(row: pd.Series) -> Dict[str, float]:
+#     out = {}
+#     for group, members in SKILL_GROUPS.items():
+#         out[group] = safe_mean([float(row.get(m, 0.0)) for m in members])
+#     return out
+
+
+# def polar_radar(df: pd.DataFrame, grouped: bool, title: str):
+#     if df.empty:
+#         return go.Figure()
+
+#     if grouped:
+#         labels = list(SKILL_GROUPS.keys())
+#         traces = []
+#         for _, r in df.iterrows():
+#             grp = aggregate_groups(r)
+#             values = [grp[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
+#         traces = []
+#         for _, r in df.iterrows():
+#             values = [float(r.get(k, 0.0)) for k in SKILLS]
+#             traces.append(
+#                 go.Scatterpolar(r=values + [values[0]], theta=labels + [labels[0]], name=r["label"], fill="toself")
+#             )
+
+#     fig = go.Figure(traces)
+#     fig.update_layout(
+#         title=title or "Skill Radar",
+#         showlegend=True,
+#         polar=dict(radialaxis=dict(range=[0, 1.0], tickvals=[0.2, 0.4, 0.6, 0.8])),
+#         margin=dict(l=30, r=30, t=60, b=30),
+#     )
+#     return fig
+
+
+# # ------------------- Data Loaders -------------------
+# @st.cache_data(show_spinner=False)
+# def parse_summary_files(files) -> pd.DataFrame:
+#     """Uploads: list of per-student summary JSON files"""
+#     rows = []
+#     for f in files or []:
+#         try:
+#             data = json.loads(f.read().decode("utf-8"))
+#         except Exception:
+#             f.seek(0)
+#             data = json.load(f)
+#         name = data.get("Name") or data.get("Student") or "Unknown"
+#         scores = data.get("Average Skill Scores") or {}
+#         row = {"label": name}
+#         for k in SKILLS:
+#             row[k] = float(scores.get(k, 0.0))
+#         rows.append(row)
+#     return pd.DataFrame(rows)
+
+
+# @st.cache_data(show_spinner=False)
+# def mongo_records(db_name: str, coll_name: str, student: str | None, source: str | None, start: str | None, end: str | None) -> List[dict]:
+#     if not (db_name and coll_name):
+#         return []
+#     user = quote_plus(os.getenv("MONGO_USER"))
+#     password = quote_plus(os.getenv("MONGO_PASS"))
+#     cluster = os.getenv("MONGO_CLUSTER")
+#     # db_name = os.environ.get("MONGO_DB", "grant_docs")
+#     mongo_uri = f"mongodb+srv://{user}:{password}@{cluster}/{db_name}?retryWrites=true&w=majority&tls=true&tlsAllowInvalidCertificates=true"
+#     client = MongoClient(mongo_uri, tls=True, tlsAllowInvalidCertificates=True, serverSelectionTimeoutMS=20000)
+#     # client = MongoClient(uri, serverSelectionTimeoutMS=6000)
+#     coll = client[db_name][coll_name]
+
+#     q = {}
+#     if student and student != "(All)":
+#         q["student"] = student
+#     if source and source != "(All)":
+#         q["source"] = source
+#     if start or end:
+#         q["date"] = {}
+#         if start:
+#             q["date"]["$gte"] = start
+#         if end:
+#             q["date"]["$lte"] = end
+
+#     cur = coll.find(q, {"_id": 0, "student": 1, "source": 1, "date": 1, "skills": 1})
+#     recs = []
+#     for r in cur:
+#         r.setdefault("skills", {})
+#         r["skills"] = {k: float(r["skills"].get(k, 0.0)) for k in SKILLS}
+#         recs.append(r)
+#     return recs
+
+
+# @st.cache_data(show_spinner=False)
+# def mongo_distinct( db_name: str, coll_name: str, field: str) -> List[str]:
+#     if not (db_name and coll_name):
+#         return []
+#     try:
+#         user = quote_plus(os.getenv("MONGO_USER"))
+#         password = quote_plus(os.getenv("MONGO_PASS"))
+#         cluster = os.getenv("MONGO_CLUSTER")
+#         mongo_uri = f"mongodb+srv://{user}:{password}@{cluster}/{db_name}?retryWrites=true&w=majority&tls=true&tlsAllowInvalidCertificates=true"
+#         client = MongoClient(mongo_uri, tls=True, tlsAllowInvalidCertificates=True, serverSelectionTimeoutMS=20000)
+#         # client = MongoClient(uri, serverSelectionTimeoutMS=6000)
+#         coll = client[db_name][coll_name]
+#         vals = coll.distinct(field)
+#         return sorted([v for v in vals if isinstance(v, str) and v.strip()])
+#     except Exception:
+#         return []
+
+
+# # ------------------- UI -------------------
+# st.title("Student Skill Radar — Streamlit")
+
+# with st.sidebar:
+#     st.subheader("Data Source")
+#     data_source = st.radio("Select source", ["Upload JSON summaries", "MongoDB"], index=0)
+#     use_groups = st.toggle("Grouped skills (skill clusters)", value=False)
+#     agg_level = st.selectbox("Aggregation level", ["student", "student+source"], index=0, help="How to average records before plotting")
+#     chart_title = st.text_input("Chart title", value="")
+
+# if data_source == "Upload JSON summaries":
+#     files = st.file_uploader("Upload 1+ summary JSON files", type=["json"], accept_multiple_files=True)
+#     df = parse_summary_files(files)
+
+#     # Student dropdown based on uploaded files
+#     labels = ["(All)"] + (sorted(df["label"].unique().tolist()) if not df.empty else [])
+#     selected = st.sidebar.selectbox("Select student", labels)
+
+#     if selected != "(All)" and not df.empty:
+#         df = df[df["label"] == selected]
+
+# else:
+#     st.sidebar.subheader("MongoDB Settings")
+#     # default_uri = st.secrets.get("MONGO_URI", "")
+#     # mongo_uri = st.sidebar.text_input("MongoDB URI", value=default_uri, type="password")
+#     db_name = st.sidebar.text_input("Database name", value="student_skills")
+#     coll_name = st.sidebar.text_input("Collection name", value="responses_IFE_2025")
+
+#     # Dynamic dropdowns from MongoDB
+#     students = ["(All)"] + mongo_distinct(db_name, coll_name, "student")
+#     sources = ["(All)"] + mongo_distinct(db_name, coll_name, "source")
+
+#     student_choice = st.sidebar.selectbox("Select student", students)
+#     source_choice = st.sidebar.selectbox("Select source/week", sources)
+
+#     c1, c2 = st.sidebar.columns(2)
+#     start_date = c1.text_input("Start date (YYYY-MM-DD)", value="")
+#     end_date = c2.text_input("End date (YYYY-MM-DD)", value="")
+
+#     recs = mongo_records(db_name, coll_name, student_choice, source_choice, start_date or None, end_date or None)
+#     df_raw = to_frame(recs)
+#     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 = df_raw.groupby("label")[SKILLS].mean().reset_index()
+#     else:
+#         df = pd.DataFrame()
+
+# # ------------------- Output -------------------
+# left, right = st.columns([2, 1])
+
+# with left:
+#     fig = polar_radar(df if not df.empty else pd.DataFrame(), use_groups, chart_title)
+#     st.plotly_chart(fig, use_container_width=True)
+
+# with right:
+#     st.subheader("Averaged Scores")
+#     if df.empty:
+#         st.info("No data yet. Upload summaries or configure MongoDB, then select a student.")
+#     else:
+#         st.dataframe(df, use_container_width=True, height=450)
+#         # CSV download
+#         csv = df.to_csv(index=False).encode("utf-8")
+#         st.download_button("Download CSV", data=csv, file_name="skill_scores.csv", mime="text/csv")
+
+# # # --------------- README (for reference in Space) ---------------
+# # """
+# # To deploy on Hugging Face Spaces:
+# # 1) Create a new Space → SDK: Streamlit → Python.
+# # 2) Add `app.py` and `requirements.txt` below.
+# # 3) (Optional) Add a Secret named `MONGO_URI` for your Mongo connection.
+
+# # Accepted Schemas
+# # - Summary JSON (per student):
+# #   {
+# #     "Name": "Student Name",
+# #     "Average Skill Scores": {"Problem-Solving": 0.6, ...}
+# #   }
+# # - MongoDB record (per response):
+# #   {
+# #     "uid": "...", "student": "...", "source": "week_2", "date": "YYYY-MM-DD",
+# #     "prompt": "...", "answer": "...",
+# #     "skills": { "Problem-Solving": 0.6, "Collaboration": 0.7, ... }
+# #   }
+# # """