Update app.py

app.py

@@ -1,118 +1,272 @@
-import os
+# app.py
+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
-import tempfile
 from pymongo import MongoClient
-from datetime import datetime
-from pathlib import Path
-from document_chunker import DocumentChunker
-from urllib.parse import quote_plus
-
-# === MongoDB connection via Hugging Face secrets ===
-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)
-db = client[db_name]
-st.set_page_config(page_title="Doc Chunker", layout="wide")
-def gate_ui():
-    APP_PASSWORD=st.secrets.get("APP_PASSWORD", os.getenv("APP_PASSWORD")).strip()
-    if "authed" not in st.session_state:
-         st.session_state.authed = False
-
-    if not APP_PASSWORD:
-        st.session_state.authed = True
-        return True
-    if st.session_state.authed:
-        return True
-    st.title("🔒 Document Chunker Login")
-    pwd=st.text_input("Enter password", type="password")
-    if st.button("Login"):
-        if pwd==APP_PASSWORD:
-            st.session_state.authed=True
-            st.rerun()
-        else:
-            st.error("Incorrect password.")
-    return False
-# === Streamlit UI ===
-def main():
-    if not gate_ui():
-        return
-    st.title("📄 Document Chunker & Uploader")
-    
-    with st.sidebar:
-        st.header("Settings")
-    
-        # Fetch collection names for dropdown
+
+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:
-            existing_categories = db["final_chunks"].distinct("collection_category") or []
+            data = json.loads(f.read().decode("utf-8"))
         except Exception:
-            existing_categories = []
-        existing_categories=sorted([c for c in existing_categories if c])+["Create New Category"]
-        selected_category = st.selectbox(
-            "Choose Category (collection_category)",
-            existing_categories,
-            index=existing_categories.index("Create New Category") if "Create New Category" in existing_categories else 0
-        )
-        if selected_category == "Create New Category":
-            selected_category = st.sidebar.text_input("Enter Category Name:")
-            if not selected_category:
-                st.warning("⚠️ Enter a category name to proceed.")
-                st.stop()
-    
-        is_grant_app = st.toggle("Is this a Grant Application?", value=False)
-    
-    uploaded_file = st.file_uploader("Upload a DOCX, TXT, or PDF file", type=["docx", "txt", "pdf"])
-    
-    if uploaded_file:
-        temp_path = Path(tempfile.gettempdir()) / uploaded_file.name
-        with open(temp_path, "wb") as f:
-            f.write(uploaded_file.getbuffer())
-    
-        st.success(f"Uploaded `{uploaded_file.name}`")
-    
-        modified_time = datetime.now().isoformat()
-        collection = db['final_chunks']
-        already = collection.find_one({
-            "metadata.title": uploaded_file.name,
-            "collection_category": selected_category
-        })
-    
-        if already:
-            st.warning(f"⚠️ `{uploaded_file.name}` already exists in category `{selected_category}`. Skipping…")
+            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(uri: str, db_name: str, coll_name: str, student: str | None, source: str | None, start: str | None, end: str | None) -> List[dict]:
+    if not (uri and db_name and coll_name):
+        return []
+    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(uri: str, db_name: str, coll_name: str, field: str) -> List[str]:
+    if not (uri and db_name and coll_name):
+        return []
+    try:
+        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="grant_docs")
+    coll_name = st.sidebar.text_input("Collection name", value="doc_chunks")
+
+    # Dynamic dropdowns from MongoDB
+    students = ["(All)"] + mongo_distinct(mongo_uri, db_name, coll_name, "student")
+    sources = ["(All)"] + mongo_distinct(mongo_uri, 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(mongo_uri, 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:
-            st.write("⏳ Processing with DocumentChunker...")
-            chunker = DocumentChunker()
-            chunks = chunker.process_document(str(temp_path))
-    
-            if chunks:
-                for chunk in chunks:
-                    chunk['collection_category']=selected_category
-                    chunk['metadata'].update({
-                        "title": uploaded_file.name,
-                        "uploaded_at": modified_time,
-                        "is_grant_app": is_grant_app,
-                    })
-                    collection.insert_one(chunk)
-    
-                st.success(f"✅ {len(chunks)} chunks inserted into `final_chunks` (category: `{selected_category}`)")
-    
-                # Show a few previews
-                for i, c in enumerate(chunks[:3]):
-                    st.subheader(f"Chunk {i+1}: {c['metadata'].get('header') or 'No Header'}")
-                    st.markdown(c['text'][:400] + "...")
-                    st.caption(f"Topics: {', '.join(c['metadata']['topics'])} | Category: {c['metadata']['category']}")
-                    st.progress(c['metadata']['confidence_score'])
-    
-                if len(chunks) > 3:
-                    st.info(f"... and {len(chunks)-3} more chunks processed.")
-    
-            else:
-                st.warning("⚠️ No chunks were generated.")
-if __name__ == "__main__":
-    main()
-    # try:
-    #     os.remove(temp_path)
-    # except Exception as e:
-    #     st.warning(f"⚠️ Could not delete temp file: {e}")
+            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, ... }
+  }
+"""