Upload 8 files

app.py

@@ -0,0 +1,354 @@
+import streamlit as st
+
+# Page Configuration
+st.set_page_config(
+    page_title="Bloomsphere - Cognitive Learning Platform",
+    page_icon="🌱",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+st.markdown("""
+    <style>
+            .stMainBlockContainer {
+            padding: 32px 50px;
+        }
+        .stAppHeader {
+            position: relative;
+            height: 0;
+            }
+    .st-emotion-cache-oj1fi {
+    display: flex
+;
+    justify-content: center;
+    align-items: center;
+    margin-top: 0px;
+}
+    </style>
+""", unsafe_allow_html=True)
+
+# Custom CSS with Enhanced Spacing and Animations
+st.markdown("""
+    <style>
+        :root {
+            --primary: #2E7D32;
+            --secondary: #388E3C;
+            --accent: #81C784;
+            --light: #E8F5E9;
+            --dark: #1B5E20;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .main {
+            background: linear-gradient(135deg, var(--light) 0%, var(--accent) 100%);
+            font-family: 'Inter', sans-serif;
+        }
+        
+        .header-container {
+            text-align: center;
+            padding: 4rem 0 8rem 0;
+            margin-bottom: 10rem;
+        }
+        
+        .main-title {
+            color: var(--dark);
+            font-size: 3.5rem;
+            font-weight: 800;
+            margin-bottom: 1rem;
+        }
+        
+        .tagline {
+            color: var(--secondary);
+            font-size: 1.5rem;
+            margin-bottom: 3rem;
+        }
+        
+        .comparison-section {
+            background: rgba(255,255,255,0.9);
+            border-radius: 20px;
+            padding: 3rem;
+            margin: 2rem 0;
+            box-shadow: 0 8px 25px rgba(0,0,0,0.05);
+        }
+        
+        .bloom-card {
+            padding: 1rem;
+            margin: 1rem 0;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 6px 20px rgba(0,0,0,0.05);
+            transition: all 0.3s ease;
+        }
+        
+        .bloom-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+        }
+        
+        .feature-card {
+            padding: 0.5rem;
+            background: white;
+            border-radius: 20px;
+            height: 100%;
+            box-shadow: 0 6px 20px rgba(0,0,0,0.05);
+            transition: all 0.3s ease;
+        }
+        
+        .feature-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+        }
+        
+        .footer {
+            background: var(--dark);
+            color: white;
+            padding: 2rem;
+            margin-top: 4rem;
+            margin-bottom: 0;
+            border-radius: 20px 20px 0 0;
+        }
+        
+        .problem-column {
+            padding: 1.5rem;
+            border-right: 2px solid var(--light);
+        }
+        
+        .solution-column {
+            padding: 1.5rem;
+        }
+        
+        @media (max-width: 768px) {
+            .problem-column {
+                border-right: none;
+                border-bottom: 2px solid var(--light);
+                padding-bottom: 2rem;
+                margin-bottom: 2rem;
+            }
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# App Header
+st.markdown("""
+    <div class="header-container">
+        <div class="main-title">🌿 Bloomsphere</div>
+        <div class="tagline">Next-Gen Cognitive Learning Platform</div>
+    </div>
+""", unsafe_allow_html=True)
+
+# Educational Landscape Comparison
+with st.container():
+    st.markdown("""
+        <style>
+            .comparison-section {
+                text-align: center;
+                margin-bottom: 2rem;
+            }
+            .problem-column, .solution-column {
+                padding: 1rem;
+                border-radius: 8px;
+            }
+            .problem-column {
+                background-color: #ffe5e5;
+            }
+            .solution-column {
+                background-color: #e5f5e5;
+            }
+            h3 {
+                margin-bottom: 1.5rem;
+                text-align: center;
+            }
+            .problem-column p, .solution-column p {
+                color: #444;
+                line-height: 1.8;
+            }
+        </style>
+        
+        <div class="comparison-section">
+            <h2 style="color: #333;">Transforming Educational Assessment</h2>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("""
+            <div class="problem-column">
+                <h3 style="color: #d32f2f;">❌ Current Challenges</h3>
+                <p>• One-size-fits-all assessments</p>
+                <p>• Subjective difficulty evaluation</p>
+                <p>• Limited cognitive level tracking</p>
+                <p>• Manual paper creation processes</p>
+                <p>• No standardized quality metrics</p>
+            </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown("""
+            <div class="solution-column">
+                <h3 style="color: #007BFF;">✅ Bloomsphere Solution</h3>
+                <p>• AI-powered cognitive alignment</p>
+                <p>• Real-time Bloom's Taxonomy analysis</p>
+                <p>• Detailed skill matrix visualization</p>
+                <p>• Automated quality assurance</p>
+                <p>• Data-driven insights & reporting</p>
+            </div>
+        """, unsafe_allow_html=True)
+
+# Bloom's Taxonomy Section
+st.markdown("""
+    <h1 style="color: var(--dark); text-align: center; margin: 4rem 0 2rem 0;">
+        🧠 Powered by Bloom's Taxonomy Framework
+    </h1>
+""", unsafe_allow_html=True)
+
+cols = st.columns(3, gap="large")
+with cols[0]:
+    st.markdown("""
+        <div class="bloom-card">
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.3rem;">📚 Remember</h3>
+            <p style="color: #666; font-size: 0.95rem; margin-bottom: 1rem;">Foundation of knowledge retention and recall</p>
+            <div style="color: #666; font-size: 0.9rem; line-height: 1.6;">
+                <div style="margin-bottom: 0.5rem;">• Fact retention</div>
+                <div style="margin-bottom: 0.5rem;">• Concept identification</div>
+                <div>• Basic comprehension</div>
+            </div>
+        </div>
+        
+        <div class="bloom-card">
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.3rem;">🔍 Analyze</h3>
+            <p style="color: #666; font-size: 0.95rem; margin-bottom: 1rem;">Critical examination of information structures</p>
+            <div style="color: #666; font-size: 0.9rem; line-height: 1.6;">
+                <div style="margin-bottom: 0.5rem;">• Pattern recognition</div>
+                <div style="margin-bottom: 0.5rem;">• Relationship mapping</div>
+                <div>• Error detection</div>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
+
+with cols[1]:
+    st.markdown("""
+        <div class="bloom-card">
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.3rem;">💡 Understand</h3>
+            <p style="color: #666; font-size: 0.95rem; margin-bottom: 1rem;">Meaning construction and interpretation</p>
+            <div style="color: #666; font-size: 0.9rem; line-height: 1.6;">
+                <div style="margin-bottom: 0.5rem;">• Concept explanation</div>
+                <div style="margin-bottom: 0.5rem;">• Information categorization</div>
+                <div>• Knowledge translation</div>
+            </div>
+        </div>
+        
+        <div class="bloom-card">
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.3rem;">📈 Evaluate</h3>
+            <p style="color: #666; font-size: 0.95rem; margin-bottom: 1rem;">Strategic judgment and decision making</p>
+            <div style="color: #666; font-size: 0.9rem; line-height: 1.6;">
+                <div style="margin-bottom: 0.5rem;">• Quality assessment</div>
+                <div style="margin-bottom: 0.5rem;">• Argument validation</div>
+                <div>• Solution critique</div>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
+
+with cols[2]:
+    st.markdown("""
+        <div class="bloom-card">
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.3rem;">🛠️ Apply</h3>
+            <p style="color: #666; font-size: 0.95rem; margin-bottom: 1rem;">Practical implementation of knowledge</p>
+            <div style="color: #666; font-size: 0.9rem; line-height: 1.6;">
+                <div style="margin-bottom: 0.5rem;">• Problem solving</div>
+                <div style="margin-bottom: 0.5rem;">• Procedure execution</div>
+                <div>• Scenario simulation</div>
+            </div>
+        </div>
+        
+        <div class="bloom-card">
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.3rem;">🚀 Create</h3>
+            <p style="color: #666; font-size: 0.95rem; margin-bottom: 1rem;">Original synthesis and innovation</p>
+            <div style="color: #666; font-size: 0.9rem; line-height: 1.6;">
+                <div style="margin-bottom: 0.5rem;">• Conceptual design</div>
+                <div style="margin-bottom: 0.5rem;">• Hypothesis formulation</div>
+                <div>• System development</div>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Features Section
+st.markdown("""
+    <h1 style="color: var(--dark); text-align: center; margin: 4rem 0 3rem 0;">
+        ✨ Key Features
+    </h1>
+""", unsafe_allow_html=True)
+
+# Feature Cards
+feat_col1, feat_col2, feat_col3 = st.columns(3, gap="large")
+
+with feat_col1:
+    st.markdown("""
+        <div class="feature-card">
+            <div style="font-size: 2rem; margin-bottom: 1rem; color: var(--primary);">📝</div>
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.2rem;">
+                Smart Paper Generation
+            </h3>
+            <p style="color: #666; font-size: 0.95rem; line-height: 1.6;display:flex; text-align: center;">
+                Create Bloom's-aligned question papers with defined difficulty balancing 
+                and cognitive levels.
+            </p>
+        </div>
+    """, unsafe_allow_html=True)
+
+with feat_col2:
+    st.markdown("""
+        <div class="feature-card">
+            <div style="font-size: 2rem; margin-bottom: 1rem; color: var(--primary);">🔍</div>
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.2rem;">
+                Cognitive Analysis
+            </h3>
+            <p style="color: #666; font-size: 0.95rem; line-height: 1.6; display:flex; text-align: center;">
+                Get instant Bloom's Taxonomy breakdowns with complexity scores.
+            </p>
+        </div>
+    """, unsafe_allow_html=True)
+
+with feat_col3:
+    st.markdown("""
+        <div class="feature-card">
+            <div style="font-size: 2rem; margin-bottom: 1rem; color: var(--primary);">📊</div>
+            <h3 style="color: var(--primary); margin-bottom: 1rem; font-size: 1.2rem;">
+                Learning Analytics
+            </h3>
+            <p style="color: #666; font-size: 0.95rem; line-height: 1.6; display:flex; text-align: center;">
+                Track performance by comparing answers with standard rubrics.
+            </p>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Action Buttons
+st.markdown("<div style='height: 2rem'></div>", unsafe_allow_html=True)
+btn_col1, btn_col2, btn_col3 = st.columns(3, gap="large")
+
+with btn_col1:
+    if st.button("Try Question Generator →", key="generator", 
+                help="Create customized question papers using AI"):
+        st.switch_page("pages/question_paper.py")
+
+with btn_col2:
+    if st.button("Analyze Papers Now →", key="analyzer", 
+                help="Get detailed paper quality analysis"):
+        st.switch_page("pages/judge_paper.py")
+
+with btn_col3:
+    if st.button("View Analytics →", key="analytics", 
+                help="Explore learning analytics dashboard"):
+        st.switch_page("pages/learning_analytics.py")
+
+# Footer
+st.markdown("""
+    <div class='footer'>
+        <div style='text-align: center;'>
+            <h3 style='color: white; margin-bottom: 1rem;'>🌐 Bloomsphere Ecosystem</h3>
+            <p style='color: var(--light); margin-bottom: 0.5rem;'>© 2025 Bloomsphere</p>
+            <small style='color: var(--accent);'>Cultivating Growth Through Cognitive Science</small>
+        </div>
+    </div>
+""", unsafe_allow_html=True)

helper.py

@@ -0,0 +1,371 @@
+import pdfplumber
+from langchain.text_splitter import CharacterTextSplitter
+from openai import OpenAI
+import json
+import numpy as np
+import time
+import re
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from dotenv import load_dotenv
+import os
+load_dotenv()
+
+def process_file(filepath):
+    """Process file and generate chunks"""
+    content = []
+    with pdfplumber.open(filepath) as pdf:
+        for page in pdf.pages:
+            text = page.extract_text()
+            if text:  # Avoid NoneType errors
+                content.append(text)
+
+    # Join extracted text with proper spacing
+    full_text = "\n\n".join(content)
+    
+    # Apply chunking
+    text_splitter = CharacterTextSplitter(
+        chunk_size=50000,
+        chunk_overlap=10
+    )
+
+    chunks = text_splitter.split_text(full_text)
+
+    # Vectorize and get similarities
+    query = ""
+    vectorizer = TfidfVectorizer()
+    vectors = vectorizer.fit_transform([query] + chunks)
+    cosine_similarities = cosine_similarity(vectors[0:1], vectors[1:]).flatten()
+    
+    # Select top chunks
+    if len(chunks) > 8:
+        top_n = int(len(chunks)/2)
+    else:
+        top_n = len(chunks)
+    if len(query) < 5:
+        top_n = len(chunks)
+    top_indices = cosine_similarities.argsort()[-top_n:][::-1]
+
+    return chunks
+
+    
+def givemcqquestion(chunks, create, evaluate, analyze, apply, understand, remember, level,questions):
+    if level == 1:
+        game = "easy and non-tricky with simple options"
+    elif level == 2:
+        game = "tricky and medium-level lengthy questions"
+    elif level == 3:
+        game = "hard and tricky and lengthy questions"
+    else:
+        raise ValueError("Invalid level. Choose 1 (easy), 2 (medium), or 3 (hard).")
+
+    prompt = f"""You are an AI designed to generate high-quality {game} level multiple-choice questions (MCQs) for educational assessments, following Bloom’s Taxonomy. Your task is to create a well-structured question that aligns with the given cognitive level, ensuring it accurately reflects the required depth of understanding.
+
+Instructions:
+For each Bloom’s Taxonomy level, follow the guidelines below to ensure appropriate question complexity:
+- **Knowledge (Remembering)**: Formulate a factual or recall-based question.
+- **Comprehension (Understanding)**: Create a question that requires explanation or interpretation.
+- **Application (Applying)**: Develop a question that applies knowledge to a new situation.
+- **Analysis (Analyzing)**: Design a question that encourages breaking down concepts.
+- **Synthesis (Creating)**: Construct a question requiring idea combination or new approaches.
+- **Evaluation (Evaluating)**: Generate a question that involves judgment or assessment.
+
+STRICT RULES:
+- Generate exactly **{questions} MCQ** based on the given context and Bloom’s Taxonomy level.
+- Return the response as a **structured JSON object** without any additional text.
+- The question should reflect the complexity required for the given cognitive level.
+- Options should be **plausible, with only one correct answer** clearly identifiable.
+- Ensure a structured rubric to evaluate student responses.
+
+Input Parameters:
+- **Context**: {chunks} (Relevant learning material)
+- **Bloom’s Taxonomy Distribution**:
+  - Understanding: {understand*100}%
+  - Analysis: {analyze*100}%
+  - Evaluation: {evaluate*100}%
+  - Synthesis: {create*100}%
+  - Application: {apply*100}%
+  - Knowledge: {remember*100}%
+
+Expected JSON Output Format:
+
+{{
+  "question": "<Your MCQ Question>",
+  "options": {{
+    "A": "<Option A>",
+    "B": "<Option B>",
+    "C": "<Option C>",
+    "D": "<Option D>"
+  }},
+  "correct_answer": "<Correct Option>",
+  "rubric": {{
+    "key_concept_assessed": "<Briefly explain what is being tested>",
+    "criteria_for_correct_answer": "<Explain why the correct answer is correct>",
+    "common_misconceptions": "<List potential incorrect assumptions>",
+    "cognitive_skill_tested": "<Describe how it aligns with Bloom’s Taxonomy>"
+  }}
+}}
+
+"""
+    print("API KEY",os.getenv("API_KEY"))
+    print("BASE URL",os.getenv("GENERATOR_BASE_URL"))
+    print("MODEL NAME",os.getenv("MODEL_NAME"))
+    client = OpenAI(
+        api_key=os.getenv("API_KEY"),
+        base_url=os.getenv("GENERATOR_BASE_URL")
+    )
+
+    response = client.chat.completions.create(
+        model=os.getenv("MODEL_NAME"),
+        messages=[{"role": "user", "content": prompt}]
+    )
+
+    mcq = response.choices[0].message.content
+    if "```json" in mcq:
+      mcq = mcq.replace("```json","")
+      mcq = mcq.replace("```","")
+    mcq = mcq.replace("\n","")
+    mcq = json.loads(mcq)
+    return mcq,prompt
+
+
+def givetruefalsequestion(chunks, create, evaluate, analyze, apply, understand, remember, level,questions):
+    if level == 1:
+        game = "easy and straightforward statements"
+    elif level == 2:
+        game = "moderate complexity with slight trickiness"
+    elif level == 3:
+        game = "complex and tricky statements requiring deep understanding"
+    else:
+        raise ValueError("Invalid level. Choose 1 (easy), 2 (medium), or 3 (hard).")
+
+    prompt = f"""You are an AI designed to generate high-quality {game} level **True/False** questions for educational assessments, following Bloom’s Taxonomy. Your task is to create a well-structured **True/False** question that aligns with the given cognitive level, ensuring it accurately reflects the required depth of understanding.
+
+    ### **Instructions:**
+    For each Bloom’s Taxonomy level, follow the guidelines below to ensure appropriate question complexity:
+    - **Knowledge (Remembering)**: Generate a straightforward fact-based statement.
+    - **Comprehension (Understanding)**: Formulate a statement that requires explanation or interpretation.
+    - **Application (Applying)**: Develop a statement that applies knowledge to a new situation.
+    - **Analysis (Analyzing)**: Design a statement that involves breaking down concepts.
+    - **Synthesis (Creating)**: Construct a statement requiring combining ideas or new approaches.
+    - **Evaluation (Evaluating)**: Generate a statement requiring judgment or assessment.
+
+    ### **STRICT RULES:**
+    - Generate exactly **{questions}** True/False question.
+    - Return the response as a **structured JSON object** without any additional text.
+    - The question should reflect the complexity required for the given cognitive level.
+    - Ensure a structured rubric to evaluate student responses.
+
+    ### **Input Parameters:**
+    - **Context**: {chunks} (Relevant learning material)
+    - **Bloom’s Taxonomy Distribution**:
+    - Understanding: {understand*100}%
+    - Analysis: {analyze*100}%
+    - Evaluation: {evaluate*100}%
+    - Synthesis: {create*100}%
+    - Application: {apply*100}%
+    - Knowledge: {remember*100}%
+
+    ### **Expected JSON Output Format:**
+    ```json
+    {{
+    "statement": "<Your True/False Statement>",
+    "correct_answer": "<True or False>",
+    "rubric": {{
+        "key_concept_assessed": "<Briefly explain what is being tested>",
+        "criteria_for_correct_answer": "<Explain why the correct answer is correct>",
+        "common_misconceptions": "<List potential incorrect assumptions>",
+        "cognitive_skill_tested": "<Describe how it aligns with Bloom’s Taxonomy>"
+    }}
+    }}
+    """
+    client = OpenAI(
+        api_key=os.getenv("API_KEY"),
+        base_url=os.getenv("GENERATOR_BASE_URL")
+    )
+
+    response = client.chat.completions.create(
+        model=os.getenv("MODEL_NAME"),
+        messages=[{"role": "user", "content": prompt}]
+    )
+
+    tf_question = response.choices[0].message.content
+    if "```json" in tf_question:
+        tf_question = tf_question.replace("```json", "").replace("```", "")
+    tf_question = tf_question.replace("\n", "")
+    tf_question = json.loads(tf_question)
+    return tf_question
+
+
+
+
+def giveopenquestion(chunks, create, evaluate, analyze, apply, understand, remember, level, questions):
+    # Validate input parameters
+    bloom_params = {
+        'create': create,
+        'evaluate': evaluate,
+        'analyze': analyze,
+        'apply': apply,
+        'understand': understand,
+        'remember': remember
+    }
+    
+    if not all(0 <= val <= 1 for val in bloom_params.values()):
+        raise ValueError("All Bloom's parameters must be between 0 and 1")
+    
+    if level not in [1, 2, 3]:
+        raise ValueError("Invalid level. Choose 1 (easy), 2 (medium), or 3 (hard).")
+
+    # Complexity description
+    complexity_levels = {
+        1: "simple recall-based questions",
+        2: "moderate explanation questions", 
+        3: "complex analytical questions"
+    }
+    complexity = complexity_levels.get(level)
+
+    prompt = f"""Generate {questions} open-ended question(s) based on the provided context, strictly following these requirements:
+
+    ### CONTEXT:
+    {chunks}
+
+    ### BLOOM'S TAXONOMY DISTRIBUTION:
+    - Creating: {create*100}%
+    - Evaluating: {evaluate*100}%
+    - Analyzing: {analyze*100}%
+    - Applying: {apply*100}%
+    - Understanding: {understand*100}%
+    - Remembering: {remember*100}%
+
+    ### COGNITIVE LEVEL:
+    {complexity} (Level {level})
+
+    ### OUTPUT REQUIREMENTS:
+    - Return ONLY valid JSON format
+    - Include detailed rubric with cognitive skill mapping
+    - For each question, specify which Bloom's level it primarily targets
+
+    ### RESPONSE FORMAT:
+    ```json
+    {{
+        "metadata": {{
+            "blooms_distribution": {{
+                "create": {create},
+                "evaluate": {evaluate},
+                "analyze": {analyze},
+                "apply": {apply},
+                "understand": {understand},
+                "remember": {remember}
+            }},
+            "complexity_level": {level}
+        }},
+        "questions": [
+            {{
+                "question": "Question text",
+                "primary_blooms_level": "create|evaluate|analyze|apply|understand|remember",
+                "rubric": {{
+                    "key_concept": "...",
+                    "criteria": "...",
+                    "misconceptions": "...",
+                    "cognitive_skills": {{
+                        "primary": "...",
+                        "secondary": ["...", "..."]
+                    }}
+                }}
+            }}
+        ]
+    }}
+    ```
+    """
+
+    client = OpenAI(
+        api_key=os.getenv("API_KEY"),
+        base_url=os.getenv("GENERATOR_BASE_URL")
+    )
+
+    try:
+        response = client.chat.completions.create(
+            model=os.getenv("MODEL_NAME"),
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=1200
+        )
+        raw_response = response.choices[0].message.content
+
+        # Extract JSON from response
+        json_match = re.search(r'```json(.*?)```', raw_response, re.DOTALL)
+        json_str = json_match.group(1).strip() if json_match else raw_response.strip()
+
+        # Parse and validate JSON
+        result = json.loads(json_str)
+        
+        # Validate structure
+        if not all(key in result for key in ['metadata', 'questions']):
+            raise ValueError("Response missing required fields")
+            
+        return result
+
+    except json.JSONDecodeError as e:
+        print(f"JSON Decode Error: {e}")
+        print(f"Problematic response:\n{raw_response}")
+        raise
+    except Exception as e:
+        print(f"API Error: {e}")
+        raise
+    
+
+
+def generate_questions_from_file(filepath, mcq, tf, qna, create, evaluate, analyze, apply, understand, remember, level):
+    """Main function to generate questions from file"""
+    # Process file first
+    chunks = process_file(filepath)
+    
+    # Generate questions using existing functionality
+    MAX_RETRIES = 3
+    RETRY_DELAY = 1
+    
+    def get_random_chunk():
+        return chunks[np.random.randint(len(chunks))] if chunks else ""
+    
+    def generate_questions(q_type, count, generator):
+        results = []
+        for _ in range(count):
+            for attempt in range(MAX_RETRIES):
+                try:
+                    chunk = get_random_chunk()
+                    question = generator(chunk, create, evaluate, analyze, apply, 
+                                       understand, remember, level, questions=1)
+                    results.append(question)
+                    break
+                except Exception as e:
+                    print(f"Error generating {q_type} question (attempt {attempt+1}): {str(e)}")
+                    if attempt == MAX_RETRIES - 1:
+                        results.append({"error": f"Failed to generate {q_type} question"})
+                    time.sleep(RETRY_DELAY)
+        return results
+
+    return {
+        'mcq': generate_questions("MCQ", mcq, givemcqquestion),
+        'tf': generate_questions("True/False", tf, givetruefalsequestion),
+        'qna': generate_questions("Q&A", qna, giveopenquestion)
+    }
+
+if __name__ == "__main__":
+    # Example usage
+    filepath = "data/eco.pdf"
+    mcq = 1
+    tf = 1
+    qna = 1
+    level = 1
+    create = 0.2
+    evaluate = 0.2
+    analyze = 0.2
+    apply = 0.2
+    understand = 0.2
+    remember = 0.2
+    
+    questions = generate_questions_from_file(
+        filepath, mcq, tf, qna, create, evaluate, 
+        analyze, apply, understand, remember, level
+    )
+    print(questions)

helper2.py

@@ -0,0 +1,122 @@
+import google.generativeai as genai
+from PIL import Image
+from dotenv import load_dotenv
+import os
+load_dotenv()
+
+genai.configure(api_key="AIzaSyCo0UmOYwiSKUD7-cCVg94M4U1xIKeoS00")
+def extract_questions_from_image(image_path):
+    image = Image.open(image_path)
+    model = genai.GenerativeModel("gemini-1.5-flash")
+    prompt = (
+        "Analyze the provided image and extract all the questions present in it. "
+        "Return only the extracted questions in a structured format, as follows:\n\n"
+        "**Output Format:**\n"
+        "Q1: [First question]\n"
+        "Q2: [Second question]\n"
+        "Q3: [Third question]\n"
+        "... \n\n"
+        "If there are no questions in the image, return 'None' without any additional text."
+    )
+    response = model.generate_content([image, prompt])
+    return response.text.strip()
+
+from PyPDF2 import PdfReader
+import google.generativeai as genai
+
+def extract_questions_from_pdf(pdf_path):
+    # Read text from the PDF
+    pdf_reader = PdfReader("sst.pdf")
+    text = "\n".join([page.extract_text() for page in pdf_reader.pages if page.extract_text()])
+    
+    # Initialize the AI model
+    model = genai.GenerativeModel("gemini-1.5-flash")
+    prompt = (
+        "Analyze the provided text and extract all the questions present in it. "
+        "Return only the extracted questions in a structured format, as follows:\n\n"
+        "**Output Format:**\n"
+        "Q1: [First question]\n"
+        "Q2: [Second question]\n"
+        "Q3: [Third question]\n"
+        "... \n\n"
+        "If there are no questions in the text, return 'None' without any additional text."
+    )
+    
+    # Generate response
+    response = model.generate_content([text, prompt])
+    return response.text.strip()
+
+file_path = "data/sst.pdf"  # Change this to your file path
+if file_path.lower().endswith((".png", ".jpg", ".jpeg")):
+    result = extract_questions_from_image(file_path)
+elif file_path.lower().endswith(".pdf"):
+    result = extract_questions_from_pdf(file_path)
+else:
+    result = "Unsupported file format. Please use PNG, JPG, or PDF."
+# Print the extracted questions
+qw = result.split("\n")
+
+from openai import OpenAI
+client = OpenAI(
+        api_key=os.getenv('API_KEY'),
+        base_url=os.getenv('GENERATOR_BASE_URL'),
+)
+prompt = """
+Analyze the following sentence and classify it according to Bloom's Taxonomy levels. 
+Return the results as a probability distribution where the sum of all 6 levels equals 1.
+
+Bloom's Taxonomy Levels:
+1. Remembering: Recall facts and basic concepts
+2. Understanding: Explain ideas or concepts
+3. Applying: Use information in new situations
+4. Analyzing: Draw connections among ideas
+5. Evaluating: Justify a stand or decision
+6. Creating: Produce new or original work
+
+For the given sentence, provide your assessment in JSON format with the following structure:
+{{
+    "remembering": float,
+    "understanding": float,
+    "applying": float,
+    "analyzing": float,
+    "evaluating": float,
+    "creating": float
+}}
+
+Ensure that:
+- Each value is between 0 and 1
+- The sum of all six values equals exactly 1
+- The distribution reflects the cognitive level required by the sentence
+
+Sentence to analyze: "{input_sentence}"
+
+Return only the JSON output without any additional explanation or commentary.
+"""
+
+import json
+
+# iterate through q1 and pass it to get response
+for i in qw:
+    formatted_prompt = prompt.format(input_sentence=i)
+    response = client.chat.completions.create(
+        model=os.getenv("MODEL_NAME"),
+        messages=[{"role": "user", "content": formatted_prompt}]
+    )
+    
+    # Extract the content from the response
+    response_content = response.choices[0].message.content
+    
+    # Clean the response (remove markdown code blocks if present)
+    json_str = response_content.strip().replace('```json', '').replace('```', '').strip()
+    
+    try:
+        # Parse the JSON string
+        bloom_scores = json.loads(json_str)
+        
+        print("\n")
+        print("sentence:", i)
+        print("Bloom Score:")
+        print(json.dumps(bloom_scores, indent=4))  # Pretty print the JSON
+    except json.JSONDecodeError as e:
+        print(f"Error parsing JSON: {e}")
+        print("Raw response:", response_content)

pages/judge_paper.py

@@ -0,0 +1,317 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+import random
+import google.generativeai as genai
+from PIL import Image
+from PyPDF2 import PdfReader
+from openai import OpenAI
+import json
+import tempfile
+# Load environment variables
+load_dotenv()
+
+genai.configure(api_key="AIzaSyCo0UmOYwiSKUD7-cCVg94M4U1xIKeoS00")
+
+# Page Configuration
+st.set_page_config(page_title="Paper Scoring", page_icon="📄", layout="wide")
+
+st.markdown("""
+    <style>
+            .stMainBlockContainer {
+            padding: 20px 50px;
+        }
+        .stAppHeader {
+            position: relative;
+            height: 0;
+            }
+    </style>
+""", unsafe_allow_html=True)
+
+# Custom CSS for Styling
+st.markdown("""
+    <style>
+        .upload-container {
+            background-color: #f0f2f6;
+            border-radius: 10px;
+            padding: 20px;
+            border: 2px dashed #4a6cf7;
+            text-align: center;
+        }
+        
+        .score-breakdown {
+            background-color: #f8f9fa;
+            border-radius: 8px;
+            padding: 15px;
+            margin-bottom: 15px;
+        }
+        .score-header {
+            font-weight: bold;
+            color: #4a6cf7;
+            margin-bottom: 10px;
+        }
+        .stProgress > div > div > div {
+            background-color: #4a6cf7;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# Back Button
+if st.button("← Back to Dashboard", key="back_btn"):
+    st.switch_page("app.py")
+
+def parse_questions_from_response(response_text):
+    """Parse questions from LLM response and return a list of questions."""
+    questions = []
+    if response_text and response_text.strip() != 'None':
+        lines = response_text.strip().split('\n')
+        for line in lines:
+            line = line.strip()
+            if line:
+                # Extract the question part after the "Q#:" prefix
+                if ':' in line:
+                    question = line.split(':', 1)[1].strip()
+                    questions.append(question)
+                else:
+                    questions.append(line)
+    return questions
+
+def extract_questions_from_image(image_path):
+    image = Image.open(image_path)
+    model = genai.GenerativeModel("gemini-1.5-flash")
+    prompt = (
+        "Extract all questions from this image and format them as a numbered list. "
+        "Use this exact format:\n"
+        "Q1: [question text]\n"
+        "Q2: [question text]\n"
+        "...\n"
+        "Only include actual questions. Return 'None' if no questions are found.\n"
+        "Do not include any other text or explanations."
+    )
+    response = model.generate_content([image, prompt])
+    return parse_questions_from_response(response.text.strip())
+
+def extract_questions_from_pdf(pdf_path):
+    pdf_reader = PdfReader(pdf_path)
+    text = "\n".join([page.extract_text() for page in pdf_reader.pages if page.extract_text()])
+    
+    model = genai.GenerativeModel("gemini-1.5-flash")
+    prompt = (
+        "Extract all questions from this text and format them as a numbered list. "
+        "Use this exact format:\n"
+        "Q1: [question text]\n"
+        "Q2: [question text]\n"
+        "...\n"
+        "Only include actual questions. Return 'None' if no questions are found.\n"
+        "Do not include any other text or explanations."
+    )
+    
+    response = model.generate_content([text, prompt])
+    return parse_questions_from_response(response.text.strip())
+
+def parse_bloom_scores(response_content):
+    """Parse and validate Bloom's taxonomy scores from LLM response."""
+    try:
+        # Clean the response
+        json_str = response_content.strip().replace('```json', '').replace('```', '').strip()
+        scores = json.loads(json_str)
+        
+        # Normalize keys to title case to match display format
+        normalized_scores = {
+            k.title(): v for k, v in scores.items()
+        }
+        
+        # Validate required keys
+        required_keys = ['Remembering', 'Understanding', 'Applying', 
+                        'Analyzing', 'Evaluating', 'Creating']
+        if not all(key in normalized_scores for key in required_keys):
+            raise ValueError("Missing required taxonomy levels")
+        
+        # Validate values are floats between 0 and 1
+        for key, value in normalized_scores.items():
+            if not isinstance(value, (int, float)) or not 0 <= value <= 1:
+                raise ValueError(f"Invalid score value for {key}: {value}")
+        
+        # Normalize scores to ensure they sum to 1
+        total = sum(normalized_scores.values())
+        if total != 0:  # Avoid division by zero
+            normalized_scores = {k: v/total for k, v in normalized_scores.items()}
+        
+        return normalized_scores
+    except (json.JSONDecodeError, ValueError) as e:
+        st.error(f"Error parsing Bloom's taxonomy scores: {str(e)}")
+        return None
+
+def get_bloom_scores(question):
+    client = OpenAI(
+        api_key=os.getenv("API_KEY"),
+        base_url=os.getenv("GENERATOR_BASE_URL"),
+
+    )
+    
+    prompt = """
+    Analyze the following sentence and classify it according to Bloom's Taxonomy levels. 
+    Return the results as a probability distribution where the sum of all 6 levels equals 1.
+    
+    Bloom's Taxonomy Levels:
+    1. Remembering: Recall facts and basic concepts
+    2. Understanding: Explain ideas or concepts
+    3. Applying: Use information in new situations
+    4. Analyzing: Draw connections among ideas
+    5. Evaluating: Justify a stand or decision
+    6. Creating: Produce new or original work
+    
+    For the given sentence, provide your assessment ONLY as a JSON object with this exact structure, no other text:
+    {
+        "remembering": float,
+        "understanding": float,
+        "applying": float,
+        "analyzing": float,
+        "evaluating": float,
+        "creating": float
+    }
+    """
+    
+    formatted_prompt = prompt + f'\nSentence to analyze: "{question}"'
+    
+    response = client.chat.completions.create(
+        model=os.getenv("MODEL_NAME"),
+        messages=[{"role": "user", "content": formatted_prompt}], temperature=0.0
+    )
+    
+    return parse_bloom_scores(response.choices[0].message.content.strip())
+
+def process_content(uploaded_file=None, text_content=None):
+    questions = []
+    if uploaded_file:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_file.name)[1]) as tmp_file:
+            tmp_file.write(uploaded_file.getvalue())
+            tmp_path = tmp_file.name
+            
+        if uploaded_file.name.lower().endswith((".png", ".jpg", ".jpeg")):
+            questions = extract_questions_from_image(tmp_path)
+        elif uploaded_file.name.lower().endswith(".pdf"):
+            questions = extract_questions_from_pdf(tmp_path)
+        
+        os.unlink(tmp_path)
+    elif text_content:
+        questions = [text_content]
+    
+    results = []
+    for question in questions:
+        if question.strip():
+            scores = get_bloom_scores(question)
+            if scores:  # Only add if scores were successfully parsed
+                results.append({
+                    'question': question,
+                    'score': scores
+                })
+    
+    return results
+
+def main():
+    st.markdown("<h1 style='font-size: 28px;'>📄 Academic Paper Scoring System</h1>", unsafe_allow_html=True)
+    st.markdown("Evaluate the Quality of Your Academic Paper")
+    
+    # Initialize session state
+    if 'question_typed' not in st.session_state:
+        st.session_state.question_typed = ""
+    
+    with st.container():
+        with st.form(key='paper_scorer_form'):
+            st.header("Upload Academic Paper")
+            
+            # File uploader
+            uploaded_file = st.file_uploader(
+                "Choose a PDF file", 
+                type=['pdf', 'jpg', 'png', 'jpeg'],
+                label_visibility="collapsed"
+            )
+            
+            st.markdown("<div style='text-align: center; margin: 20px 0;'><strong>OR</strong></div>", 
+                        unsafe_allow_html=True)
+            
+            # Text input
+            st.session_state.question_typed = st.text_area(
+                "Paste your question here",
+                value=st.session_state.question_typed,
+                height=150
+            )
+            
+            # Submit button
+            submitted = st.form_submit_button(
+                "Score Paper",
+                use_container_width=True,
+                type="primary"
+            )
+
+    # Processing and results display
+    if submitted:
+        if uploaded_file or st.session_state.question_typed:
+            with st.spinner("Analyzing content..."):
+                results = process_content(uploaded_file, st.session_state.question_typed)
+                if results:
+                    st.success("Analysis complete!")
+                    display_results(results)
+                else:
+                    st.error("Failed to process the document. Please try again.")
+        else:
+            st.warning("Please upload a file or enter text to score")
+
+def display_results(results):
+    # Calculate total scores
+    total_score = {category: 0 for category in ['Remembering', 'Understanding', 'Applying', 
+                                               'Analyzing', 'Evaluating', 'Creating']}
+    for item in results:
+        for category in total_score:
+            total_score[category] += item['score'][category]
+
+    # Overall score card
+    with st.container():
+        st.subheader("Overall Bloom's Taxonomy Scores")
+        cols = st.columns(6)
+        categories = ['Remembering', 'Understanding', 'Applying', 
+                     'Analyzing', 'Evaluating', 'Creating']
+        
+        for i, (col, category) in enumerate(zip(cols, categories)):
+            with col:
+                score = round(total_score[category] / len(results), 3)
+                color = "#4a6cf7" if score >= 0.7 else "#ffa500" if score >= 0.4 else "#dc3545"
+                
+                st.markdown(f"""
+                <div class="score-breakdown">
+                    <div class="score-header" style="color: {color}">{category}</div>
+                    <div style="font-size: 24px; color: {color};">{score}/1.0</div>
+                </div>
+                """, unsafe_allow_html=True)
+
+    # Detailed breakdown
+    with st.expander("View Detailed Question Analysis", expanded=True):
+        for idx, item in enumerate(results, 1):
+            st.markdown(f'<div class="score-header">Question {idx}: {item["question"]}</div>', 
+                       unsafe_allow_html=True)
+            
+            # Create columns for score display
+            cols = st.columns(6)
+            for col, category in zip(cols, categories):
+                with col:
+                    score = round(item['score'][category], 3)
+                    color = "#4a6cf7" if score > 0.7 else "#ffa500" if score > 0.3 else "#dc3545"
+                    
+                    st.markdown(f"""
+                    <div style="text-align: center; 
+                                background-color: #f1f1f1; 
+                                border-radius: 5px; 
+                                padding: 5px; 
+                                margin-bottom: 5px;">
+                        <div style="font-weight: bold; color: {color};">{category}</div>
+                        <div style="font-size: 18px; color: {color};">{score}/1</div>
+                    </div>
+                    """, unsafe_allow_html=True)
+            
+            if idx < len(results):
+                st.markdown("---")
+
+if __name__ == "__main__":
+    main()
+

pages/learning_analytics.py

@@ -0,0 +1,380 @@
+import streamlit as st
+import json
+import re
+import spacy
+from sklearn.feature_extraction.text import TfidfVectorizer
+from openai import OpenAI
+from dotenv import load_dotenv
+import os
+load_dotenv()
+import subprocess
+
+
+client = OpenAI(
+    api_key=os.getenv("API_KEY"),
+    base_url=os.getenv("GENERATOR_BASE_URL")
+)
+
+def ensure_spacy_model():
+    """Ensure the required spaCy model is installed."""
+    model_name = "en_core_web_sm"
+    try:
+        spacy.load(model_name)
+    except OSError:
+        print(f"Downloading spaCy model: {model_name}...")
+        subprocess.run(["python", "-m", "spacy", "download", model_name], check=True)
+
+def extract_key_components(rubric_text):
+    """Dynamically extract key terms from rubric using NLP."""
+    ensure_spacy_model()  # Ensure the model is downloaded
+    nlp = spacy.load("en_core_web_sm")
+    doc = nlp(rubric_text)
+
+    entities = set(ent.text.lower() for ent in doc.ents)
+    noun_chunks = set(chunk.text.lower() for chunk in doc.noun_chunks)
+
+    vectorizer = TfidfVectorizer(ngram_range=(1, 2), stop_words='english')
+    tfidf_matrix = vectorizer.fit_transform([rubric_text])
+    feature_names = vectorizer.get_feature_names_out()
+    tfidf_scores = zip(feature_names, tfidf_matrix.toarray()[0])
+    top_terms = [term for term, score in sorted(tfidf_scores, key=lambda x: x[1], reverse=True)[:15]]
+
+    return list(entities.union(noun_chunks).union(top_terms))
+
+def evaluate_student_answer(student_answer, rubric):
+    def preprocess(text):
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', '', text)
+        return text.strip()
+
+    cleaned_answer = preprocess(student_answer)
+    features = {}
+
+    rubric_text = f"{rubric['criteria_for_correct_answer']} {rubric['common_misconceptions']}"
+    key_terms = extract_key_components(rubric_text)
+    features['keyword_coverage'] = sum(1 for term in key_terms if term in cleaned_answer)/len(key_terms)
+
+    doc = spacy.load("en_core_web_sm")(student_answer)
+    features['key_entities_present'] = len([ent for ent in doc.ents if ent.text.lower() in key_terms])
+
+    prompt = f"""Evaluate this answer against the rubric. Consider:
+    - Keyword matches: {features.get('keyword_coverage', 0)*100:.1f}%
+    - Key entities found: {features.get('key_entities_present', 0)}
+
+    Rubric Criteria:
+    {rubric['criteria_for_correct_answer']}
+
+    Common Misconceptions:
+    {rubric['common_misconceptions']}
+
+    Student Answer:
+    {student_answer}
+
+    Return JSON with score (0-10), breakdown - (accuracy, relevance and completeness), and feedback strictly."""
+    
+    try:
+        response = client.chat.completions.create(
+            model=os.getenv("MODEL_NAME"),
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            response_format={"type": "json_object"}
+        )
+        llm_output = response.choices[0].message.content
+        return json.loads(llm_output)
+    except Exception as e:
+        print(f"API Error: {str(e)}")
+        return {
+            "score": 0,
+            "breakdown": {"accuracy": 0, "relevance": 0, "completeness": 0},
+            "feedback": "Evaluation service unavailable"
+        }
+
+# -------------------- Streamlit UI --------------------
+st.set_page_config(page_title="Answer Evaluation System", layout="wide", page_icon="📘")
+
+
+st.markdown("""
+    <style>
+            .stMainBlockContainer {
+            padding: 20px 50px;
+        }
+        .stAppHeader {
+            position: relative;
+            height: 0;
+            }
+    </style>
+""", unsafe_allow_html=True)
+
+
+st.markdown("""
+    <style>
+    .main {padding: 2rem 3rem;}
+    .header {color: #2b3b52; border-bottom: 2px solid #eee;}
+    .stTextArea textarea {border: 1px solid #e1e4e8 !important;}
+    .score-container {background: #f8f9fa; border-radius: 10px; padding: 25px; margin: 20px 0;}
+    .feedback-box {background: #fffbe6; border-left: 4px solid #ffd700; border-radius: 5px; padding: 20px; margin: 25px 0;}
+    .metric-box {background: white; border-radius: 8px; padding: 20px; margin: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);}
+    .metric-box h1 {color: #2b3b52; margin: 5px 0;}
+    .stButton button {transition: all 0.3s ease;}
+    .stButton button:hover {transform: translateY(-2px);}
+    </style>
+""", unsafe_allow_html=True)
+
+EXAMPLES = {
+    "Select an example...": {"rubric": {}, "answer": ""},
+    
+    "LDA Analysis": {
+        "rubric": {
+            "key_concept_assessed": "Understanding of Linear Discriminant Analysis (LDA) as a supervised dimensionality reduction technique and its application in pattern recognition",
+            "criteria_for_correct_answer": (
+                "A complete answer should:\n"
+                "1. Differentiate LDA from PCA in terms of supervision and objective\n"
+                "2. Explain the mathematical goal of maximizing between-class variance while minimizing within-class variance\n"
+                "3. Describe the assumption of normal distribution and equal class covariance matrices\n"
+                "4. Provide real-world applications in fields like bioinformatics or facial recognition"
+            ),
+            "common_misconceptions": (
+                "1. Confusing LDA with Latent Dirichlet Allocation (same acronym)\n"
+                "2. Believing LDA is primarily a classification algorithm rather than dimensionality reduction\n"
+                "3. Assuming LDA requires no normality assumptions\n"
+                "4. Thinking LDA and PCA are interchangeable for unsupervised problems"
+            ),
+            "cognitive_skill_tested": (
+                "Analysis: Requires breaking down LDA's mathematical framework\n"
+                "Evaluation: Comparing/contrasting with similar techniques like PCA\n"
+                "Application: Demonstrating understanding through practical use cases"
+            )
+        },
+        "answer": (
+            "Linear Discriminant Analysis (LDA) is a supervised dimensionality reduction technique that maximizes class separability by:\n\n"
+            "1. Calculating between-class and within-class scatter matrices\n"
+            "2. Finding linear combinations of features that maximize Fisher's ratio: (between-class variance)/(within-class variance)\n"
+            "3. Assuming multivariate normal distributions with equal covariance across classes\n\n"
+            "Key applications include:\n"
+            "- Preprocessing for classification tasks in speech recognition\n"
+            "- Gene expression analysis in bioinformatics\n"
+            "- Feature extraction in computer vision systems\n\n"
+            "Unlike PCA which maximizes variance without class information, LDA explicitly uses class labels to find discriminative directions."
+        )
+    },
+    
+    "Climate Change Basics": {
+        "rubric": {
+            "key_concept_assessed": "Understanding of anthropogenic climate change mechanisms and evidence-based reasoning",
+            "criteria_for_correct_answer": (
+                "An exemplary response must:\n"
+                "1. Identify main greenhouse gases (CO₂, CH₄, N₂O) and their sources\n"
+                "2. Explain the enhanced greenhouse effect using radiative forcing\n"
+                "3. Distinguish between natural climate variability and anthropogenic forcing\n"
+                "4. Reference IPCC assessment reports and paleoclimate evidence"
+            ),
+            "common_misconceptions": (
+                "1. Equating ozone depletion with climate change\n"
+                "2. Attributing current warming solely to solar cycles\n"
+                "3. Confusing weather variability with long-term climate trends\n"
+                "4. Overemphasizing natural CO₂ sources while ignoring anthropogenic contributions"
+            ),
+            "cognitive_skill_tested": (
+                "Comprehension: Interpreting climate proxies and modern observations\n"
+                "Evaluation: Assessing credibility of different evidence types\n"
+                "Synthesis: Integrating physical, chemical, and biological data"
+            )
+        },
+        "answer": (
+            "Modern climate change is primarily driven by human activities through:\n\n"
+            "1. Fossil fuel combustion (75% of CO₂ emissions)\n"
+            "2. Agricultural practices (40% of CH₄ from livestock and rice paddies)\n"
+            "3. Deforestation reducing carbon sinks (12-17% of anthropogenic emissions)\n\n"
+            "Key evidence includes:\n"
+            "- 50% increase in atmospheric CO₂ since 1750 (415 ppm vs 280 ppm pre-industrial)\n"
+            "- Isotopic fingerprint showing fossil fuel origin of CO₂ increase\n"
+            "- Stratospheric cooling/tropospheric warming pattern characteristic of greenhouse forcing\n"
+            "- Observed sea level rise (3.7 mm/yr) matching model predictions\n\n"
+            "Natural factors like solar irradiance and volcanic activity cannot explain the current warming trend (IPCC AR6)."
+        )
+    },
+
+    "Market Equilibrium": {
+        "rubric": {
+            "key_concept_assessed": "Understanding of price mechanism and market adjustment processes",
+            "criteria_for_correct_answer": (
+                "A strong answer should:\n"
+                "1. Define equilibrium price/quantity using supply-demand curves\n"
+                "2. Analyze effects of price floors/ceilings with real examples\n"
+                "3. Explain elasticity's role in tax incidence\n"
+                "4. Distinguish between short-run and long-run adjustments"
+            ),
+            "common_misconceptions": (
+                "1. Believing equilibrium implies no transactions\n"
+                "2. Assuming price controls benefit all consumers/producers\n"
+                "3. Confusing movement along curves with shift of curves\n"
+                "4. Thinking elasticity is constant across price ranges"
+            ),
+            "cognitive_skill_tested": (
+                "Application: Using graphical models to predict market outcomes\n"
+                "Evaluation: Assessing welfare impacts of policy interventions\n"
+                "Synthesis: Connecting abstract models to real-world markets"
+            )
+        },
+        "answer": (
+            "Market equilibrium occurs when:\n\n"
+            "Qd(P) = Qs(P)\n\n"
+            "Key concepts:\n"
+            "1. Price ceiling (e.g., rent control) creates shortages when below equilibrium\n"
+            "2. Price floor (e.g., minimum wage) creates surpluses when above equilibrium\n"
+            "3. Tax incidence depends on relative elasticity - inelastic side bears more burden\n\n"
+            "Adjustment process:\n"
+            "- Short-run: Inventory changes and queuing\n"
+            "- Long-run: Entry/exit of firms and technological adaptation\n\n"
+            "Example: Gasoline taxes largely borne by consumers due to inelastic demand."
+        )
+    }
+}
+
+def main():
+    # Session State Initialization
+    if 'rubric' not in st.session_state:
+        st.session_state.rubric = {}
+    if 'answer' not in st.session_state:
+        st.session_state.answer = ""
+
+    # Back Button
+    if st.button("← Back to Dashboard", key="back_btn"):
+        st.switch_page("app.py")
+
+    # Page Header
+    st.markdown("<h1 class='header'>📚 Automated Answer Evaluation System</h1>", unsafe_allow_html=True)
+
+    # Example Selector
+    selected_example = st.selectbox("Load example scenario:", options=list(EXAMPLES.keys()))
+
+    # Handle Example Selection
+    if selected_example == "Select an example...":
+        st.session_state.rubric = {}
+        st.session_state.answer = ""
+    else:
+        example = EXAMPLES[selected_example]
+        st.session_state.rubric = example["rubric"]
+        st.session_state.answer = example["answer"]
+
+    # Rubric Input Section
+    with st.expander("🎯 Rubric Input", expanded=True):
+        col1, col2 = st.columns(2)
+        with col1:
+            key_concept = st.text_area(
+                "Key Concept Assessed", 
+                value=st.session_state.rubric.get("key_concept_assessed", ""),
+                placeholder="What key concept is being assessed?",
+                height=150
+            )
+            criteria = st.text_area(
+                "Criteria for Correct Answer", 
+                value=st.session_state.rubric.get("criteria_for_correct_answer", ""),
+                placeholder="What defines a correct answer?",
+                height=150
+            )
+        with col2:
+            misconceptions = st.text_area(
+                "Common Misconceptions", 
+                value=st.session_state.rubric.get("common_misconceptions", ""),
+                placeholder="What common errors should be watched for?",
+                height=150
+            )
+            cognitive_skill = st.text_area(
+                "Cognitive Skill Tested", 
+                value=st.session_state.rubric.get("cognitive_skill_tested", ""),
+                placeholder="Which cognitive skills are being tested?",
+                height=150
+            )
+
+    # Student Answer Section
+    student_answer = st.text_area(
+        "📝 Student Answer", 
+        value=st.session_state.answer,
+        placeholder="Paste the student's answer here...",
+        height=300
+    )
+
+    # Action Buttons
+    col1, col2, col3 = st.columns([1,1,2])
+    with col1:
+        if st.button("🧹 Clear All", use_container_width=True):
+            st.session_state.rubric = {}
+            st.session_state.answer = ""
+            st.rerun()
+    with col2:
+        evaluate_btn = st.button("🔍 Evaluate Answer", use_container_width=True)
+
+    # Evaluation Logic
+    if evaluate_btn:
+        if not all([key_concept, criteria, misconceptions, cognitive_skill]) or not student_answer:
+            st.warning("❗ Please complete all rubric fields and provide a student answer!")
+            return
+
+        rubric = {
+            "key_concept_assessed": key_concept,
+            "criteria_for_correct_answer": criteria,
+            "common_misconceptions": misconceptions,
+            "cognitive_skill_tested": cognitive_skill
+        }
+
+        with st.spinner("🔍 Analyzing answer..."):
+            try:
+                result = evaluate_student_answer(student_answer, rubric)
+                
+                # Results Display
+                st.markdown("---")
+                st.markdown("<h2 style='color: #2b3b52'>Evaluation Results</h2>", unsafe_allow_html=True)
+                
+                # Score Container
+                with st.container():
+                    st.markdown(f"""
+                        <div class='score-container'>
+                            <h2>Overall Score: {result.get('score', 0)}/10</h2>
+                        </div>
+                    """, unsafe_allow_html=True)
+                
+                # Metrics
+                cols = st.columns(3)
+                metrics = result.get('breakdown', {})
+                with cols[0]:
+                    st.markdown(f"""
+                        <div class='metric-box'>
+                            <h4>📐 Accuracy</h4>
+                            <h1>{metrics.get('accuracy', 0)}</h1>
+                        </div>
+                    """, unsafe_allow_html=True)
+                with cols[1]:
+                    st.markdown(f"""
+                        <div class='metric-box'>
+                            <h4>✅ Completeness</h4>
+                            <h1>{metrics.get('completeness', 0)}</h1>
+                        </div>
+                    """, unsafe_allow_html=True)
+                with cols[2]:
+                    st.markdown(f"""
+                        <div class='metric-box'>
+                            <h4>🎯 Relevance</h4>
+                            <h1>{metrics.get('relevance', 0)}</h1>
+                        </div>
+                    """, unsafe_allow_html=True)
+                
+                # Feedback
+                st.markdown(f"""
+                    <div class='feedback-box'>
+                        <h4>📌 Detailed Feedback</h4>
+                        <p>{result.get('feedback', 'No feedback available')}</p>
+                    </div>
+                """, unsafe_allow_html=True)
+                
+                # Raw JSON
+                with st.expander("View Raw JSON Output"):
+                    st.json(result)
+
+            except Exception as e:
+                st.error(f"🚨 Evaluation Error: {str(e)}")
+
+if __name__ == "__main__":
+    main()
+
+

pages/question_paper.py

@@ -0,0 +1,583 @@
+import streamlit as st
+import json
+import os
+from datetime import datetime
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from reportlab.lib import colors
+from reportlab.lib.utils import simpleSplit
+import random   
+from helper import generate_questions_from_file
+from dotenv import load_dotenv
+import os
+load_dotenv()
+
+# Page Configuration
+st.set_page_config(page_title="Question Paper Generator", page_icon="📝", layout="wide")
+
+st.markdown("""
+    <style>
+            .stMainBlockContainer {
+            padding: 20px 50px;
+        }
+        .stAppHeader {
+            position: relative;
+            height: 0;
+            }
+    </style>
+""", unsafe_allow_html=True)
+
+# Custom CSS for Enhanced Styling
+st.markdown("""
+    <style>
+        :root {
+            --primary: #2E7D32;
+            --secondary: #388E3C;
+            --accent: #81C784;
+            --light: #E8F5E9;
+            --dark: #1B5E20;
+        }
+            
+        
+        
+        .section-header {
+            font-size: 1.4rem;
+            font-weight: 600;
+            color: var(--primary);
+            margin: 1.5rem 0 1rem 0;
+            padding-bottom: 0.5rem;
+            border-bottom: 2px solid var(--accent);
+        }
+        
+        .question-card {
+            padding: 1.5rem;
+            margin: 1rem 0;
+            background: #FFFFFF;
+            border-radius: 10px;
+            box-shadow: 0 2px 6px rgba(0,0,0,0.1);
+            border-left: 4px solid var(--accent);
+            transition: all 0.3s ease;
+        }
+        
+        .question-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+        }
+        
+        .selected-question {
+            background: var(--light) !important;
+            border-left: 4px solid var(--primary) !important;
+        }
+        
+        .stSelectbox, .stTextArea, .stNumberInput {
+            margin-bottom: 1.5rem;
+        }
+        
+        .download-btn {
+            background: var(--primary) !important;
+            color: white !important;
+            border: none !important;
+            border-radius: 8px !important;
+            padding: 10px 25px !important;
+            transition: all 0.3s ease !important;
+        }
+        
+        .download-btn:hover {
+            background: var(--secondary) !important;
+            transform: scale(1.05);
+        }
+        
+        .rubric-expander {
+            margin-top: 1rem;
+            border-left: 3px solid var(--accent);
+            padding-left: 1rem;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# Back Button
+if st.button("← Back to Dashboard", key="back_btn"):
+    st.switch_page("app.py")
+
+st.title("📝 Question Paper Generation")
+
+# Add intro instructions
+st.markdown("""
+    Welcome to the Question Paper Generator! Follow these steps to create your custom question paper:
+    1. Upload your study material in PDF format
+    2. Enter specific query or topic for questions (optional)
+    3. Select the number and types of questions
+    4. Adjust the cognitive levels using Bloom's Taxonomy
+    5. Choose difficulty level
+    6. Generate and select questions
+    7. Download your question paper
+""")
+
+# Initialize session state variables
+if 'questions' not in st.session_state:
+    st.session_state.questions = None
+if 'accepted_questions' not in st.session_state:
+    st.session_state.accepted_questions = []
+if 'generated' not in st.session_state:
+    st.session_state.generated = False
+if 'loading' not in st.session_state:
+    st.session_state.loading = False
+
+# File to store resources
+RESOURCE_FILE = "resources.json"
+
+def load_resources():
+    if os.path.exists(RESOURCE_FILE):
+        with open(RESOURCE_FILE, "r") as f:
+            return json.load(f)
+    return []
+
+def save_resources(resources):
+    with open(RESOURCE_FILE, "w") as f:
+        json.dump(resources, f, indent=4)
+
+# Step 1: Choose or Upload Resource
+st.markdown("<div class='section-header'>📚 Step 1: Upload Resource</div>", unsafe_allow_html=True)
+st.markdown("Upload your study material in PDF format. This will be used as the source for generating questions.")
+
+# Upload Resource Section
+uploaded_file = st.file_uploader("Upload PDF", type=["pdf"])
+if uploaded_file:
+    # Save file
+    UPLOADS_DIR = "uploads"
+    os.makedirs(UPLOADS_DIR, exist_ok=True)
+    file_path = os.path.join(UPLOADS_DIR, uploaded_file.name)
+    with open(file_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())
+
+# Step 2: Enter Query
+st.markdown("<div class='section-header'>🔍 Step 2: Enter Your Query</div>", unsafe_allow_html=True)
+st.markdown("Specify any particular topic or concept you want to focus on. Leave blank to generate questions from the entire material.")
+query = st.text_area("Enter your query here", height=120)
+
+# Step 3: Choose Paper Pattern
+st.markdown("<div class='section-header'>📄 Step 3: Choose Paper Pattern</div>", unsafe_allow_html=True)
+st.markdown("Select the number of questions for each type. The total should not exceed 8 questions.")
+st.warning("⚠️ Note: Due to compute resource limitations, please limit the total number of questions to 8 or fewer.")
+
+col1, col2, col3 = st.columns(3)
+with col1:
+    num_mcq = st.number_input("MCQs", min_value=0, value=3)
+with col2:
+    num_tf = st.number_input("True/False", min_value=0, value=3)
+with col3:
+    num_qa = st.number_input("Q&A", min_value=0, value=2)
+
+total_questions = num_mcq + num_tf + num_qa
+if total_questions > 10:
+    st.error("❌ Total number of questions cannot exceed 8. Please adjust your selection.")
+
+# Step 4: Bloom’s Taxonomy Weights
+st.markdown("<div class='section-header'>🎯 Step 4: Set Bloom’s Taxonomy Weights</div>", unsafe_allow_html=True)
+st.markdown("Adjust the cognitive level distribution of your questions. The total of all weights should sum to 100.")
+col1, col2 = st.columns(2)
+with col1:
+    bloom_weights = {
+        "Remembering": st.slider("Remembering", 0, 100, 20,
+                               help="Recall facts and basic concepts"),
+        "Understanding": st.slider("Understanding", 0, 100, 20,
+                                 help="Explain ideas and concepts"),
+        "Applying": st.slider("Applying", 0, 100, 20,
+                            help="Use information in new situations")
+    }
+with col2:
+    bloom_weights.update({
+        "Analyzing": st.slider("Analyzing", 0, 100, 20,
+                             help="Draw connections among ideas"),
+        "Evaluating": st.slider("Evaluating", 0, 100, 10,
+                              help="Justify decisions through evidence"),
+        "Creating": st.slider("Creating", 0, 100, 10,
+                            help="Produce original work")
+    })
+
+# Step 5: Difficulty Level
+st.markdown("<div class='section-header'>📊 Step 5: Set Difficulty Level</div>", unsafe_allow_html=True)
+st.markdown("Choose the overall difficulty level for your question paper.")
+level = st.select_slider("Select Difficulty Level", 
+                        options=["Easy", "Medium", "Hard"],
+                        value="Medium")
+
+def generate_pdf_with_rubric(questions, filename="questions_with_rubric.pdf"):
+    try:
+        c = canvas.Canvas(filename, pagesize=letter)
+        width, height = letter  # Get page size
+        
+        y_position = height - 50  # Starting position
+        
+        # Title
+        c.setFont("Helvetica-Bold", 16)
+        c.drawString(150, y_position, "Question Paper with Rubrics & Solutions")
+        y_position -= 30
+
+        for idx, q in enumerate(questions, 1):
+            if y_position < 100:  # Check if new page is needed
+                c.showPage()
+                c.setFont("Helvetica", 12)
+                y_position = height - 50
+            
+            # Question
+            c.setFont("Helvetica-Bold", 12)
+            question_text = f"Q{idx}: {q.get('question', q.get('statement', 'Question'))}"
+            wrapped_text = simpleSplit(question_text, "Helvetica-Bold", 12, width - 100)
+            
+            for line in wrapped_text:
+                c.drawString(50, y_position, line)
+                y_position -= 15
+
+            c.setFont("Helvetica", 12)
+
+            # Options for MCQ
+            if 'options' in q:
+                for opt, text in q['options'].items():
+                    wrapped_opt = simpleSplit(f"   {opt}. {text}", "Helvetica", 12, width - 100)
+                    for line in wrapped_opt:
+                        c.drawString(70, y_position, line)
+                        y_position -= 15
+
+                # Correct answer (in Green)
+                c.setFillColor(colors.green)
+                c.drawString(70, y_position, f"   Correct Answer: {q['correct_answer']}")
+                y_position -= 20
+                c.setFillColor(colors.black)
+
+            # Correct answer for True/False
+            if 'correct_answer' in q and 'options' not in q:
+                c.setFillColor(colors.green)
+                c.drawString(70, y_position, f"   Correct Answer: {q['correct_answer']}")
+                y_position -= 20
+                c.setFillColor(colors.black)
+
+            # Rubric Section
+            c.setFont("Helvetica-Oblique", 10)
+            c.setFillColor(colors.grey)
+            c.drawString(50, y_position, "Rubric:")
+            y_position -= 15
+
+            for key, value in q['rubric'].items():
+                wrapped_rubric = simpleSplit(f"{key}: {value}", "Helvetica-Oblique", 10, width - 100)
+                for line in wrapped_rubric:
+                    c.drawString(70, y_position, line)
+                    y_position -= 12
+
+            y_position -= 10  # Space before next question
+            c.setFont("Helvetica", 12)
+            c.setFillColor(colors.black)
+
+        c.save()
+        return filename
+    except Exception as e:
+        print(f"Error generating PDF: {e}")
+        return None
+
+
+def generate_pdf(questions, filename="questions.pdf"):
+    try:
+        c = canvas.Canvas(filename, pagesize=letter)
+        width, height = letter
+        y_position = height - 50  # Starting position
+        
+        # Title
+        c.setFont("Helvetica-Bold", 16)
+        c.drawString(200, y_position, "Generated Questions")
+        y_position -= 30
+
+        for i, question in enumerate(questions, 1):
+            if y_position < 100:  # Check if new page is needed
+                c.showPage()
+                c.setFont("Helvetica", 12)
+                y_position = height - 50
+
+            c.setFont("Helvetica", 12)
+            wrapped_text = simpleSplit(f"Q{i}: {question}", "Helvetica", 12, width - 100)
+
+            for line in wrapped_text:
+                c.drawString(50, y_position, line)
+                y_position -= 15
+
+        c.save()
+        return filename
+    except Exception as e:
+        print(f"Error generating PDF: {e}")
+        return None
+
+def generate_dummy_scores(num_questions=5):
+    categories = ['Remembering', 'Understanding', 'Applying', 
+                 'Analyzing', 'Evaluating', 'Creating']
+    
+    dummy_data = []
+    for i in range(num_questions):
+        question = f"Sample question about concept {i+1} in quantum mechanics?"
+        scores = {
+            category: round(random.uniform(0.2, 0.95), 2)
+            for category in categories
+        }
+        dummy_data.append({
+            'question': question,
+            'score': scores
+        })
+    return dummy_data
+
+def parse_question_response(response):
+    """
+    Parse and standardize question response into a consistent format
+    """
+    parsed_questions = {
+        'mcq': [],
+        'tf': [],
+        'qna': []
+    }
+    
+    # Parse MCQ questions
+    if 'mcq' in response:
+        for q in response['mcq']:
+            # Handle both tuple and dict formats
+            question_data = q[0] if isinstance(q, tuple) else q
+            parsed_mcq = {
+                'question': question_data.get('question', ''),
+                'options': question_data.get('options', {}),
+                'correct_answer': question_data.get('correct_answer', ''),
+                'rubric': question_data.get('rubric', {}),
+                'type': 'mcq'
+            }
+            parsed_questions['mcq'].append(parsed_mcq)
+    
+    # Parse True/False questions
+    if 'tf' in response:
+        for q in response['tf']:
+            parsed_tf = {
+                'question': q.get('statement', ''),
+                'correct_answer': q.get('correct_answer', ''),
+                'rubric': q.get('rubric', {}),
+                'type': 'tf'
+            }
+            parsed_questions['tf'].append(parsed_tf)
+    
+    # Parse Q&A questions
+    if 'qna' in response:
+        for q in response['qna']:
+            # Handle nested structure
+            if 'questions' in q:
+                question_data = q['questions'][0]
+            else:
+                question_data = q
+                
+            parsed_qna = {
+                'question': question_data.get('question', ''),
+                'rubric': question_data.get('rubric', {}),
+                'type': 'qna'
+            }
+            parsed_questions['qna'].append(parsed_qna)
+    
+    return parsed_questions
+
+def generate_questions(filename,mcq,tf,qna, create, evaluate, analyze, apply, understand, remember, level):
+    if filename:
+        file_path = os.path.join("uploads", filename)
+        sum = create + evaluate + analyze + apply + understand + remember
+        create = create / sum
+        evaluate = evaluate / sum
+        analyze = analyze / sum
+        apply = apply / sum
+        understand = understand / sum
+        remember = remember / sum
+        level = level.lower()
+        if level == "easy":
+            level = 1
+        elif level == "medium":
+            level = 2
+        else:
+            level = 3
+        # print(file_path, mcq, tf, qna, create, evaluate, analyze, apply, understand, remember, level)
+        questions = generate_questions_from_file(file_path, mcq, tf, qna, create, evaluate, analyze, apply, understand, remember, level)
+        # print(questions)
+        # print("Now parsing")
+        parsed_questions = parse_question_response(questions)
+        # print(parsed_questions)
+        return parsed_questions
+    else:
+        return {'mcq': [{'question': 'What is the primary goal of using generalized additive models in regression analysis?',
+        'options': {'A': 'To assume a linear relationship between the predictors and the response variable',
+            'B': 'To identify and characterize nonlinear regression effects',
+            'C': 'To reduce the dimensionality of the predictor space',
+            'D': 'To assume a specific distribution for the response variable'},
+        'correct_answer': 'B',
+        'rubric': {'key_concept_assessed': 'Understanding of generalized additive models',
+            'criteria_for_correct_answer': 'The correct answer is B because generalized additive models are used to model nonlinear relationships between predictors and the response variable, allowing for more flexibility in the analysis.',
+            'common_misconceptions': 'Assuming linearity, assuming a specific distribution, or reducing dimensionality are not the primary goals of generalized additive models',
+            'cognitive_skill_tested': "This question requires the ability to understand the purpose and application of generalized additive models, which aligns with the 'Understanding' category of Bloom's Taxonomy."}}],
+        'tf': [{'statement': 'The nearest shrunken centroids method uses all of the features (genes) and does not perform automatic feature selection.',
+        'correct_answer': False,
+        'rubric': {'key_concept_assessed': 'Nearest Shrunken Centroids (NSC) method for classification',
+            'criteria_for_correct_answer': 'The NSC method is designed to automatically select features by shrinking the classwise mean toward the overall mean for each feature, resulting in the removal of features with zero shrunken values.',
+            'common_misconceptions': 'Believing that NSC does not perform feature selection or assuming it uses all features without modification.',
+            'cognitive_skill_tested': 'Analysis, as the question requires understanding the mechanism of the NSC method and its implications on feature selection.'}}],
+        'qna': [{'question': 'Explain how the concept of the false discovery rate (FDR) is used in multiple hypothesis testing in the context of microarray analysis. Discuss the advantages and limitations of this approach, providing examples to illustrate your points. Consider how the choice of the FDR threshold affects the results and how it can impact the interpretation of the findings in a high-dimensional data setting.',
+        'rubric': {'key_concept_assessed': 'Understanding of the false discovery rate (FDR) and its application in multiple hypothesis testing, particularly in the context of microarray analysis',
+            'criteria_for_correct_answer': 'A correct answer should include a clear definition of FDR, its advantages in controlling the number of false positives, limitations such as dependence on the chosen threshold, and examples illustrating its application in microarray analysis. The answer should also discuss how different thresholds can lead to different conclusions and the importance of considering this in high-dimensional data analysis',
+            'common_misconceptions': 'Confusing FDR with family-wise error rate (FWER), not considering the impact of the chosen threshold on the results, and overlooking the assumptions underlying the FDR method',
+            'cognitive_skill_tested': 'This question requires the ability to analyze complex statistical concepts, evaluate their strengths and limitations, and apply them to practical problems, which aligns with the higher-order thinking skills of analysis, evaluation, and synthesis in Bloom’s Taxonomy'}}]}
+
+# Generate Paper Button
+if st.button("🎯 Generate Question Paper", key="generate_btn", disabled=st.session_state.loading):
+    if not uploaded_file:
+        st.error("Please upload a valid resource first!")
+    else:
+        with st.spinner('Generating questions... Please wait...'):
+            st.session_state.loading = True
+            st.session_state.questions = generate_questions(
+                uploaded_file.name, num_mcq, num_tf, num_qa, 
+                bloom_weights["Creating"], bloom_weights["Evaluating"],
+                bloom_weights["Analyzing"], bloom_weights["Applying"],
+                bloom_weights["Understanding"], bloom_weights["Remembering"], level
+            )
+            st.session_state.generated = True
+            st.session_state.accepted_questions = []
+            st.session_state.loading = False
+            st.rerun()
+
+# Display generated questions
+if st.session_state.generated and st.session_state.questions:
+    st.markdown("---")
+    st.subheader("Generated Questions")
+    
+    with st.form(key='question_selection'):
+        tabs = st.tabs(["MCQ", "True/False", "Q&A"])
+        
+        with tabs[0]:
+            for idx, q in enumerate(st.session_state.questions['mcq'], 1):
+                col1, col2 = st.columns([4, 1])
+                with col1:
+                    # Check if q is a tuple and get the dictionary from it if it is
+                    question_data = q[0] if isinstance(q, tuple) else q
+                    
+                    st.write(f"**Q{idx}:** {question_data['question']}")
+                    for opt, text in question_data['options'].items():
+                        st.write(f"{opt}. {text}")
+
+                    st.write(f"Correct Answer: {question_data['correct_answer']}")
+                    with st.expander("Rubric"):
+                        st.json(question_data['rubric'])
+                    create, evaluate, analyze, apply, understand, remember = generate_dummy_scores(num_questions=1)[0]['score'].values()
+
+                with col2:
+                    if st.checkbox(f"Select MCQ {idx}", key=f"mcq_{idx}"):
+                        if q not in st.session_state.accepted_questions:
+                            st.session_state.accepted_questions.append(q)
+                    else:
+                        if q in st.session_state.accepted_questions:
+                            st.session_state.accepted_questions.remove(q)
+        
+        with tabs[1]:
+            for idx, q in enumerate(st.session_state.questions['tf'], 1):
+                col1, col2 = st.columns([4, 1])
+                with col1:
+                    st.write(f"**Q{idx}:** {q['question']}")
+                    st.write(f"Correct Answer: {q['correct_answer']}")
+                    with st.expander("Rubric"):
+                        st.json(q['rubric'])
+                    create, evaluate, analyze, apply, understand, remember = generate_dummy_scores(num_questions=1)[0]['score'].values()
+                with col2:
+                    if st.checkbox(f"Select TF {idx}", key=f"tf_{idx}"):
+                        if q not in st.session_state.accepted_questions:
+                            st.session_state.accepted_questions.append(q)
+                    else:
+                        if q in st.session_state.accepted_questions:
+                            st.session_state.accepted_questions.remove(q)
+        
+        with tabs[2]:
+            # Check if 'qna' questions exist and have the expected structure
+            if 'qna' in st.session_state.questions and st.session_state.questions['qna']:
+                for idx, q_wrapper in enumerate(st.session_state.questions['qna'], 1):
+                    col1, col2 = st.columns([4, 1])
+                    with col1:
+                        # Handle the nested structure
+                        if 'questions' in q_wrapper:
+                            # Get the first question from the nested structure
+                            q = q_wrapper['questions'][0]
+                            st.write(f"**Q{idx}:** {q['question']}")
+                            with st.expander("Rubric"):
+                                st.json(q['rubric'])
+                        else:
+                            # Fallback for direct question structure
+                            q = q_wrapper
+                            st.write(f"**Q{idx}:** {q.get('question', 'No question available')}")
+                            if 'rubric' in q:
+                                with st.expander("Rubric"):
+                                    st.json(q['rubric'])
+                    
+                    with col2:
+                        if st.checkbox(f"Select Q&A {idx}", key=f"qna_{idx}"):
+                            if q_wrapper not in st.session_state.accepted_questions:
+                                st.session_state.accepted_questions.append(q_wrapper)
+                        else:
+                            if q_wrapper in st.session_state.accepted_questions:
+                                st.session_state.accepted_questions.remove(q_wrapper)
+        
+        st.form_submit_button("Update Selection")
+
+    # Accepted Questions and PDF Download
+if st.session_state.accepted_questions:
+    st.markdown("---")
+    st.subheader("✅ Accepted Questions")
+    
+    for idx, q in enumerate(st.session_state.accepted_questions, 1):
+        if isinstance(q, tuple):
+            question_data = q[0]
+        else:
+            question_data = q
+        question_text = question_data.get('question', 
+                                        question_data.get('statement', 
+                                        'Question'))
+        st.write(f"{idx}. {question_text}")
+
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        questions_for_pdf = []
+        for q in st.session_state.accepted_questions:
+            if isinstance(q, tuple):
+                questions_for_pdf.append(q[0].get('question', ''))
+            else:
+                questions_for_pdf.append(q.get('question', q.get('statement', '')))
+        
+        if questions_for_pdf:
+            filename = generate_pdf(questions_for_pdf)
+            if filename:
+                with open(filename, "rb") as f:
+                    pdf_data = f.read()
+                    st.download_button(
+                        label="⬇️ Download Basic Questions",
+                        data=pdf_data,
+                        file_name="questions.pdf",
+                        mime="application/pdf"
+                    )
+
+    with col2:
+        questions_for_pdf = []
+        for q in st.session_state.accepted_questions:
+            if isinstance(q, tuple):
+                questions_for_pdf.append(q[0])
+            else:
+                questions_for_pdf.append(q)
+        
+        if questions_for_pdf:
+            filename = generate_pdf_with_rubric(questions_for_pdf)
+            if filename:
+                with open(filename, "rb") as f:
+                    pdf_data = f.read()
+                    st.download_button(
+                        label="⬇️ Download Full Version",
+                        data=pdf_data,
+                        file_name="questions_with_rubric.pdf",
+                        mime="application/pdf"
+                    )
+
+# client = OpenAI(
+#         api_key="os.getenv("API_KEY")",
+#         base_url=os.getenv("GENERATOR_BASE_URL")
+#     )

requirements.txt

@@ -0,0 +1,10 @@
+spacy
+streamlit
+dotenv
+openai
+sklearn
+reportlab
+langchain
+pdfplumber
+pandas
+numpy

resources.json

@@ -0,0 +1 @@
+[]