Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,206 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import io
+
+def parse_quiz_file(file_content):
+    """
+    Parses the custom MD format into a list of question dictionaries.
+    """
+    questions = []
+    raw_blocks = file_content.split("-END-")
+    
+    for block in raw_blocks:
+        if not block.strip():
+            continue
+            
+        q_data = {}
+        current_key = None
+        
+        known_keys = [
+            "TOPIC", "SUB_TOPIC", "QUESTION_KEY", "BASE_QUESTION_KEYS", 
+            "QUESTION_TEXT", "CONTENT_TYPE", "QUESTION_TYPE", "LEARNING_OUTCOME", 
+            "CODE", "CODE_LANGUAGE", "OPTION_1", "OPTION_2", "OPTION_3", 
+            "OPTION_4", "CORRECT_OPTION", "EXPLANATION", "BLOOM_LEVEL"
+        ]
+        
+        lines = block.strip().split('\n')
+        
+        for line in lines:
+            match = None
+            for key in known_keys:
+                if line.startswith(f"{key}:"):
+                    match = key
+                    break
+            
+            if match:
+                current_key = match
+                val = line.split(':', 1)[1].strip()
+                q_data[current_key] = val
+            else:
+                if current_key:
+                    q_data[current_key] += "\n" + line
+
+        if "QUESTION_TEXT" in q_data and "OPTION_1" in q_data:
+            questions.append(q_data)
+            
+    return questions
+
+def generate_excel_report(questions):
+    """
+    Gathers all review notes and creates an Excel byte stream.
+    Now simplified to only include: Question Key, Question, and Review.
+    """
+    report_data = []
+    
+    # Iterate through session state to find notes
+    for idx, q in enumerate(questions):
+        note_key = f"note_{idx}"
+        # Get note from session state (if it exists)
+        note = st.session_state.get(note_key, "").strip()
+        
+        if note:
+            # Add to report with specific columns requested
+            report_data.append({
+                "Question Key": q.get('QUESTION_KEY', 'N/A'),
+                "Question": q['QUESTION_TEXT'],
+                "Review": note
+            })
+            
+    if not report_data:
+        return None
+        
+    df = pd.DataFrame(report_data)
+    
+    # Write to Excel in memory
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+        df.to_excel(writer, index=False, sheet_name='Review Notes')
+    
+    return output.getvalue()
+
+def main():
+    st.set_page_config(page_title="Quiz Review Tool", layout="wide")
+    
+    st.title("🛠️ Quiz Content Reviewer")
+    st.markdown("Test questions and flag issues for the content team.")
+
+    # 1. File Uploader
+    uploaded_file = st.file_uploader("Choose a Quiz MD file", type=['md'])
+
+    if uploaded_file is not None:
+        string_data = uploaded_file.getvalue().decode("utf-8")
+        questions = parse_quiz_file(string_data)
+        
+        if "answered_questions" not in st.session_state:
+            st.session_state["answered_questions"] = set()
+            
+        st.success(f"Loaded {len(questions)} questions for review.")
+        st.divider()
+
+        score = 0
+        total_answered = 0
+
+        # 2. Questions Loop
+        for idx, q in enumerate(questions):
+            with st.container():
+                # Header with ID
+                c1, c2 = st.columns([0.8, 0.2])
+                with c1:
+                    st.subheader(f"Q{idx+1}: {q.get('TOPIC', 'General')}")
+                with c2:
+                    st.caption(f"ID: {q.get('QUESTION_KEY', 'N/A')}")
+                
+                st.markdown(q['QUESTION_TEXT'])
+                
+                options = [
+                    q.get('OPTION_1'),
+                    q.get('OPTION_2'),
+                    q.get('OPTION_3'),
+                    q.get('OPTION_4')
+                ]
+                
+                radio_key = f"radio_{idx}"
+                is_answered = idx in st.session_state["answered_questions"]
+                
+                user_choice = st.radio(
+                    "Select Answer:", 
+                    options, 
+                    index=None, 
+                    key=radio_key,
+                    disabled=is_answered
+                )
+
+                # --- Actions Row (Submit & Review) ---
+                col_submit, col_review = st.columns([0.2, 0.8])
+                
+                # A. Submit Button Logic
+                with col_submit:
+                    if not is_answered:
+                        if st.button(f"Check Q{idx+1}", key=f"btn_{idx}"):
+                            if user_choice:
+                                st.session_state["answered_questions"].add(idx)
+                                st.rerun()
+                            else:
+                                st.warning("Select an option.")
+                
+                # B. Result Display (If Answered)
+                if is_answered:
+                    correct_key = q['CORRECT_OPTION'] 
+                    correct_text = q.get(correct_key)
+                    
+                    if user_choice == correct_text:
+                        st.success("✅ Correct")
+                        score += 1
+                    else:
+                        st.error("❌ Incorrect")
+                        st.markdown(f"**Correct:** {correct_text}")
+                    
+                    st.info(f"**Explanation:** {q.get('EXPLANATION', 'None')}")
+                    total_answered += 1
+
+                # C. Review Note Feature (Always Visible)
+                with st.expander("🚩 Flag Issue / Add Note"):
+                    st.text_area(
+                        "Describe the issue:", 
+                        key=f"note_{idx}",
+                        placeholder="Type review here..."
+                    )
+
+                st.markdown("---")
+
+        # 3. Sidebar - Stats & Export
+        with st.sidebar:
+            st.header("📊 Review Status")
+            if len(questions) > 0:
+                st.progress(total_answered / len(questions))
+                st.metric("Score", f"{score} / {total_answered}")
+            
+            st.markdown("---")
+            st.header("📥 Export Review")
+            st.write("When you are done reviewing, download the report.")
+            
+            # Count how many notes exist
+            notes_count = 0
+            for k in st.session_state:
+                if k.startswith("note_") and st.session_state[k].strip():
+                    notes_count += 1
+            
+            st.info(f"Questions Flagged: **{notes_count}**")
+            
+            if notes_count > 0:
+                excel_data = generate_excel_report(questions)
+                if excel_data:
+                    st.download_button(
+                        label="📄 Download Excel Report",
+                        data=excel_data,
+                        file_name="quiz_review_notes.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    )
+            
+            # Reset
+            if st.button("Reset All"):
+                st.session_state.clear()
+                st.rerun()
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()