Update app.py

app.py

@@ -1,4 +1,5 @@
-# app.py - Enhanced MCQ Test Generator for Hugging Face
+```python
+# app.py - Professional Test Generator for Hugging Face
 # Aligned with Pakistani National Curriculum (2006)
 # Developer: Najaf Ali Sharqi
 
@@ -23,10 +24,50 @@ client = Groq(api_key=GROQ_API_KEY)
 # ---------------------------
 # Configuration Constants
 # ---------------------------
-APP_VERSION = "2.0"
-MAX_MCQS = 20
+APP_VERSION = "3.0"
 MODEL_NAME = "llama-3.3-70b-versatile"
 
+# ---------------------------
+# Question Types Configuration
+# ---------------------------
+QUESTION_TYPES = {
+    "Multiple Choice Questions (MCQs)": {
+        "description": "Four-option questions with one correct answer",
+        "min_questions": 5,
+        "max_questions": 50,
+        "default_questions": 20,
+        "marks_per_question": 1
+    },
+    "Fill in the Blanks": {
+        "description": "Sentences with missing words to complete",
+        "min_questions": 5,
+        "max_questions": 40,
+        "default_questions": 15,
+        "marks_per_question": 1
+    },
+    "Match the Column": {
+        "description": "Two columns to match related items",
+        "min_questions": 5,
+        "max_questions": 20,
+        "default_questions": 10,
+        "marks_per_question": 1
+    },
+    "Short Response Questions": {
+        "description": "Brief written answers (2-3 sentences)",
+        "min_questions": 3,
+        "max_questions": 15,
+        "default_questions": 8,
+        "marks_per_question": 2
+    },
+    "Long Response Questions": {
+        "description": "Detailed written answers (paragraphs)",
+        "min_questions": 2,
+        "max_questions": 10,
+        "default_questions": 5,
+        "marks_per_question": 5
+    }
+}
+
 # ---------------------------
 # Grades and subjects aligned with Pakistan National Curriculum
 # ---------------------------
@@ -345,296 +386,829 @@ DIFFICULTY_LEVELS = {
 }
 
 # ---------------------------
-# Enhanced MCQ generation with proper item writing principles
+# Question Generation Functions
 # ---------------------------
-def generate_mcqs(grade, subject, chapter, difficulty, num_questions, test_type, school_name):
-    """Generate MCQs using AI with enhanced item writing guidelines"""
+def generate_mcqs(grade, subject, chapter, difficulty, num_questions):
+    """Generate Multiple Choice Questions"""
     
-    try:
-        # Build comprehensive prompt for better MCQ quality
-        system_msg = """You are an expert educational item writer and assessment specialist with deep knowledge of the Pakistani National Curriculum (2006). 
-
-Your task is to create high-quality Multiple Choice Questions (MCQs) following these professional item writing principles:
-
-1. STEM CLARITY: Write clear, concise question stems that present a single, well-defined problem
-2. PLAUSIBLE DISTRACTORS: Create wrong options that are believable based on common misconceptions
-3. GRAMMATICAL CONSISTENCY: Ensure all options are grammatically consistent with the stem
-4. AVOID CUEING: Don't use "all of the above" or "none of the above"
-5. EQUAL LENGTH: Keep options similar in length to avoid cueing the correct answer
-6. NO NEGATIVE PHRASING: Avoid "NOT" or "EXCEPT" unless absolutely necessary
-7. CURRICULUM ALIGNMENT: Base questions strictly on learning objectives from the National Curriculum
-8. AGE-APPROPRIATE: Use vocabulary and concepts suitable for the grade level
-
-Format each question exactly as:
-Q#. [Question stem]
+    system_msg = """You are an expert educational item writer specializing in Multiple Choice Questions.
+
+CRITICAL RULES:
+1. Start IMMEDIATELY with "1." - NO introductory text, preambles, or explanations
+2. Do NOT write phrases like "Here are the MCQs" or "Q1. Here are..."
+3. Begin directly with the first question
+
+Format exactly as:
+1. [Question stem]
+A) [Option 1]
+B) [Option 2]
+C) [Option 3]
+D) [Option 4]
+
+2. [Question stem]
 A) [Option 1]
 B) [Option 2]
 C) [Option 3]
 D) [Option 4]
 
-Then provide answer key at the end as:
+ITEM WRITING PRINCIPLES:
+- Clear, concise question stems
+- Plausible distractors based on common misconceptions
+- Grammatically consistent options
+- Avoid "all of the above" or "none of the above"
+- Equal length options
+- Age-appropriate vocabulary
+
+After all questions, provide:
 ANSWER KEY:
 1. B
 2. A
 etc."""
 
-        user_msg = f"""Generate {num_questions} high-quality MCQs for:
-- Grade: {grade}
-- Subject: {subject}
-- Chapter: {chapter}
-- Cognitive Level: {difficulty}
-- Test Type: {test_type}
+    user_msg = f"""Generate {num_questions} MCQs for:
+Grade: {grade}
+Subject: {subject}
+Chapter: {chapter}
+Cognitive Level: {difficulty}
 
 Requirements:
-- Align strictly with Pakistani National Curriculum (2006) learning outcomes
-- Use {difficulty} level cognitive skills: {DIFFICULTY_LEVELS.get(difficulty, {}).get('description', '')}
-- Ensure questions test {', '.join(DIFFICULTY_LEVELS.get(difficulty, {}).get('keywords', [])[:3])}
-- Make distractors plausible based on common student errors
-- Use clear, unambiguous language appropriate for {grade}
-- Balance questions across different topics within the chapter
-- Include practical applications where relevant
-
-Generate exactly {num_questions} questions with the answer key at the end."""
-
-        # Call Groq API
-        response = client.chat.completions.create(
-            messages=[
-                {"role": "system", "content": system_msg},
-                {"role": "user", "content": user_msg}
-            ],
-            model=MODEL_NAME,
-            temperature=0.7,
-            max_tokens=4000
-        )
+- Align with Pakistani National Curriculum (2006)
+- Use {difficulty} level: {DIFFICULTY_LEVELS.get(difficulty, {}).get('description', '')}
+- Test skills: {', '.join(DIFFICULTY_LEVELS.get(difficulty, {}).get('keywords', [])[:3])}
+- Clear language for {grade}
+- Plausible distractors
+- Practical applications where relevant
 
-        text = response.choices[0].message.content
-        
-        # Parse MCQs and answers
-        mcqs, answer_key = parse_mcqs_and_answers(text, num_questions)
-        
-        return mcqs, answer_key, None
-        
-    except Exception as e:
-        error_msg = f"Error generating MCQs: {str(e)}"
-        return [], [], error_msg
+START IMMEDIATELY WITH "1." - NO INTRODUCTORY TEXT."""
+
+    response = client.chat.completions.create(
+        messages=[
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": user_msg}
+        ],
+        model=MODEL_NAME,
+        temperature=0.7,
+        max_tokens=4000
+    )
+
+    return response.choices[0].message.content
+
+
+def generate_fill_blanks(grade, subject, chapter, difficulty, num_questions):
+    """Generate Fill in the Blanks Questions"""
+    
+    system_msg = """You are an expert educational item writer specializing in Fill in the Blanks questions.
+
+CRITICAL RULES:
+1. Start IMMEDIATELY with "1." - NO introductory text
+2. Do NOT write phrases like "Here are the questions"
+3. Begin directly with the first question
+
+Format exactly as:
+1. [Sentence with __________ for blank]
+
+2. [Sentence with __________ for blank]
+
+ITEM WRITING PRINCIPLES:
+- Use __________ to indicate blanks (10 underscores)
+- Only ONE blank per question
+- Blank should test key concepts
+- Context clues should be minimal
+- Unambiguous answers
+
+After all questions, provide:
+ANSWER KEY:
+1. [answer]
+2. [answer]
+etc."""
+
+    user_msg = f"""Generate {num_questions} Fill in the Blanks questions for:
+Grade: {grade}
+Subject: {subject}
+Chapter: {chapter}
+Cognitive Level: {difficulty}
+
+START IMMEDIATELY WITH "1." - NO INTRODUCTORY TEXT."""
+
+    response = client.chat.completions.create(
+        messages=[
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": user_msg}
+        ],
+        model=MODEL_NAME,
+        temperature=0.7,
+        max_tokens=3000
+    )
+
+    return response.choices[0].message.content
+
+
+def generate_match_column(grade, subject, chapter, difficulty, num_questions):
+    """Generate Match the Column Questions"""
+    
+    system_msg = """You are an expert educational item writer specializing in Match the Column questions.
+
+CRITICAL RULES:
+1. Start IMMEDIATELY with "COLUMN A" - NO introductory text
+2. Do NOT write phrases like "Here are the questions"
+3. Begin directly with the columns
+
+Format exactly as:
+COLUMN A          COLUMN B
+1. [Item A1]      a) [Item B1]
+2. [Item A2]      b) [Item B2]
+3. [Item A3]      c) [Item B3]
+4. [Item A4]      d) [Item B4]
+
+ITEM WRITING PRINCIPLES:
+- Items should be related but not obvious
+- Randomize order in Column B
+- Keep items concise
+- Clear relationships
+
+After columns, provide:
+ANSWER KEY:
+1-b, 2-d, 3-a, 4-c"""
+
+    user_msg = f"""Generate {num_questions} matching pairs for:
+Grade: {grade}
+Subject: {subject}
+Chapter: {chapter}
+Cognitive Level: {difficulty}
+
+START IMMEDIATELY WITH "COLUMN A" - NO INTRODUCTORY TEXT."""
+
+    response = client.chat.completions.create(
+        messages=[
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": user_msg}
+        ],
+        model=MODEL_NAME,
+        temperature=0.7,
+        max_tokens=2500
+    )
+
+    return response.choices[0].message.content
+
+
+def generate_short_response(grade, subject, chapter, difficulty, num_questions):
+    """Generate Short Response Questions"""
+    
+    system_msg = """You are an expert educational item writer specializing in Short Response questions.
+
+CRITICAL RULES:
+1. Start IMMEDIATELY with "1." - NO introductory text
+2. Do NOT write phrases like "Here are the questions"
+3. Begin directly with the first question
+
+Format exactly as:
+1. [Question requiring 2-3 sentence answer]
+
+2. [Question requiring 2-3 sentence answer]
+
+ITEM WRITING PRINCIPLES:
+- Questions require brief explanations (2-3 sentences)
+- Test understanding and application
+- Clear expectations
+- Specific enough to guide response length
+
+After all questions, provide:
+MARKING GUIDE:
+1. [Key points to award marks]
+2. [Key points to award marks]
+etc."""
+
+    user_msg = f"""Generate {num_questions} Short Response questions for:
+Grade: {grade}
+Subject: {subject}
+Chapter: {chapter}
+Cognitive Level: {difficulty}
+
+Each question should require 2-3 sentences to answer.
+
+START IMMEDIATELY WITH "1." - NO INTRODUCTORY TEXT."""
 
+    response = client.chat.completions.create(
+        messages=[
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": user_msg}
+        ],
+        model=MODEL_NAME,
+        temperature=0.7,
+        max_tokens=3000
+    )
+
+    return response.choices[0].message.content
+
+
+def generate_long_response(grade, subject, chapter, difficulty, num_questions):
+    """Generate Long Response Questions"""
+    
+    system_msg = """You are an expert educational item writer specializing in Long Response/Essay questions.
+
+CRITICAL RULES:
+1. Start IMMEDIATELY with "1." - NO introductory text
+2. Do NOT write phrases like "Here are the questions"
+3. Begin directly with the first question
+
+Format exactly as:
+1. [Question requiring detailed paragraph answer]
+
+2. [Question requiring detailed paragraph answer]
+
+ITEM WRITING PRINCIPLES:
+- Questions require detailed explanations (1-2 paragraphs)
+- Test analysis, evaluation, synthesis
+- Open-ended but focused
+- Clear success criteria
+
+After all questions, provide:
+MARKING RUBRIC:
+1. [Detailed marking criteria with point allocation]
+2. [Detailed marking criteria with point allocation]
+etc."""
+
+    user_msg = f"""Generate {num_questions} Long Response questions for:
+Grade: {grade}
+Subject: {subject}
+Chapter: {chapter}
+Cognitive Level: {difficulty}
+
+Each question should require 1-2 paragraphs to answer fully.
+
+START IMMEDIATELY WITH "1." - NO INTRODUCTORY TEXT."""
+
+    response = client.chat.completions.create(
+        messages=[
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": user_msg}
+        ],
+        model=MODEL_NAME,
+        temperature=0.7,
+        max_tokens=3500
+    )
+
+    return response.choices[0].message.content
+
+
+# ---------------------------
+# Parsing Functions
+# ---------------------------
 def parse_mcqs_and_answers(text, expected_count):
-    """Parse AI response to extract MCQs and answer key"""
+    """Parse MCQs and extract answer key"""
     
-    # Split by answer key section
+    # Remove any introductory text before first question
+    match = re.search(r'(?:^|\n)\s*1\.\s+', text, re.MULTILINE)
+    if match:
+        text = text[match.start():]
+    
+    # Split by answer key
     parts = re.split(r'ANSWER\s+KEY:?', text, flags=re.IGNORECASE)
     
-    mcqs = []
-    answer_key = []
+    questions = []
+    answers = []
     
     if len(parts) >= 1:
-        # Extract MCQs
         mcq_text = parts[0]
-        # Split by question numbers (1., 2., etc.)
-        questions = re.split(r'\n\s*\d+\.\s+', mcq_text)
-        questions = [q.strip() for q in questions if q.strip() and len(q.strip()) > 20]
-        mcqs = questions[:expected_count]
+        # Split by question numbers
+        qs = re.split(r'(?:^|\n)\s*\d+\.\s+', mcq_text, flags=re.MULTILINE)
+        questions = [q.strip() for q in qs if q.strip() and len(q.strip()) > 20]
+        questions = questions[:expected_count]
     
     if len(parts) >= 2:
-        # Extract answer key
         answer_text = parts[1]
-        # Find patterns like "1. B" or "1) B" or "1: B"
-        answers = re.findall(r'\d+[\.\):\s]+([A-D])', answer_text, re.IGNORECASE)
-        answer_key = [ans.upper() for ans in answers[:expected_count]]
+        ans = re.findall(r'\d+[\.\):\s]+([A-D])', answer_text, re.IGNORECASE)
+        answers = [a.upper() for a in ans[:expected_count]]
+    
+    # Ensure answer count matches questions
+    if len(answers) < len(questions):
+        answers.extend(['A'] * (len(questions) - len(answers)))
+    
+    return questions, answers
+
+
+def parse_fill_blanks(text, expected_count):
+    """Parse Fill in the Blanks questions"""
+    
+    # Remove intro text
+    match = re.search(r'(?:^|\n)\s*1\.\s+', text, re.MULTILINE)
+    if match:
+        text = text[match.start():]
+    
+    parts = re.split(r'ANSWER\s+KEY:?', text, flags=re.IGNORECASE)
+    
+    questions = []
+    answers = []
+    
+    if len(parts) >= 1:
+        q_text = parts[0]
+        qs = re.split(r'(?:^|\n)\s*\d+\.\s+', q_text, flags=re.MULTILINE)
+        questions = [q.strip() for q in qs if q.strip() and '__' in q]
+        questions = questions[:expected_count]
+    
+    if len(parts) >= 2:
+        ans_text = parts[1]
+        ans = re.findall(r'\d+[\.\):\s]+(.+?)(?=\n\d+[\.\)]|\Z)', ans_text, re.DOTALL)
+        answers = [a.strip() for a in ans[:expected_count]]
     
-    # If parsing failed, create placeholder
-    if len(answer_key) < len(mcqs):
-        answer_key.extend(['A'] * (len(mcqs) - len(answer_key)))
+    if len(answers) < len(questions):
+        answers.extend(['[Answer]'] * (len(questions) - len(answers)))
     
-    return mcqs, answer_key
+    return questions, answers
+
+
+def parse_match_column(text):
+    """Parse Match the Column questions"""
+    
+    # Find columns
+    match = re.search(r'COLUMN\s+A.*?COLUMN\s+B', text, re.IGNORECASE | re.DOTALL)
+    if not match:
+        return [], [], []
+    
+    # Extract content after column headers
+    content_start = match.end()
+    parts = re.split(r'ANSWER\s+KEY:?', text[content_start:], flags=re.IGNORECASE)
+    
+    column_a = []
+    column_b = []
+    answers = []
+    
+    if len(parts) >= 1:
+        pairs_text = parts[0]
+        lines = pairs_text.strip().split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Match pattern: "1. Item A    a) Item B"
+            match = re.match(r'(\d+)\.\s+(.+?)\s+([a-z])\)\s+(.+)', line, re.IGNORECASE)
+            if match:
+                num, item_a, letter, item_b = match.groups()
+                column_a.append(f"{num}. {item_a.strip()}")
+                column_b.append(f"{letter}) {item_b.strip()}")
+    
+    if len(parts) >= 2:
+        ans_text = parts[1]
+        # Extract matching like "1-b, 2-d, 3-a"
+        matches = re.findall(r'(\d+)-([a-z])', ans_text, re.IGNORECASE)
+        answers = [f"{num}-{letter.lower()}" for num, letter in matches]
+    
+    return column_a, column_b, answers
+
+
+def parse_short_long_response(text, expected_count):
+    """Parse Short/Long Response questions with marking guide"""
+    
+    # Remove intro text
+    match = re.search(r'(?:^|\n)\s*1\.\s+', text, re.MULTILINE)
+    if match:
+        text = text[match.start():]
+    
+    parts = re.split(r'(?:MARKING\s+GUIDE|MARKING\s+RUBRIC):?', text, flags=re.IGNORECASE)
+    
+    questions = []
+    marking_guide = []
+    
+    if len(parts) >= 1:
+        q_text = parts[0]
+        qs = re.split(r'(?:^|\n)\s*\d+\.\s+', q_text, flags=re.MULTILINE)
+        questions = [q.strip() for q in qs if q.strip() and len(q.strip()) > 15]
+        questions = questions[:expected_count]
+    
+    if len(parts) >= 2:
+        guide_text = parts[1]
+        guides = re.split(r'(?:^|\n)\s*\d+\.\s+', guide_text, flags=re.MULTILINE)
+        marking_guide = [g.strip() for g in guides if g.strip()]
+        marking_guide = marking_guide[:expected_count]
+    
+    if len(marking_guide) < len(questions):
+        marking_guide.extend(['[Marking criteria to be determined]'] * (len(questions) - len(marking_guide)))
+    
+    return questions, marking_guide
+
 
 # ---------------------------
-# Enhanced DOCX export with professional formatting
+# Master Generation Function
 # ---------------------------
-def export_to_word(mcqs, answers, grade, subject, chapter, difficulty, test_type, school_name, total_marks):
-    """Export MCQs to professionally formatted Word document"""
+def generate_questions(question_type, grade, subject, chapter, difficulty, num_questions):
+    """Master function to generate any type of question"""
     
     try:
-        doc = Document()
-        
-        # Set margins
-        sections = doc.sections
-        for section in sections:
-            section.top_margin = Inches(0.8)
-            section.bottom_margin = Inches(0.8)
-            section.left_margin = Inches(0.9)
-            section.right_margin = Inches(0.9)
-        
-        # Header with school name if provided
-        if school_name and school_name.strip():
-            school_heading = doc.add_heading(school_name.upper(), level=0)
-            school_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
-            for run in school_heading.runs:
-                run.font.size = Pt(16)
-                run.font.color.rgb = RGBColor(0, 51, 102)
-        
-        # Test title
-        test_title = doc.add_heading(f"{test_type.upper()}", level=1)
-        test_title.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        for run in test_title.runs:
-            run.bold = True
-            run.font.color.rgb = RGBColor(0, 102, 51)
-            run.font.size = Pt(16)
-        
-        # Information table
-        table = doc.add_table(rows=7, cols=2)
-        table.style = 'Light Grid Accent 1'
-        
-        info_data = [
-            ("Grade:", grade),
-            ("Subject:", subject),
-            ("Chapter:", chapter),
-            ("Cognitive Level:", difficulty),
-            ("Total Marks:", str(total_marks)),
-            ("Date:", datetime.now().strftime("%d-%m-%Y")),
-            ("Duration:", "60 minutes" if len(mcqs) > 15 else "40 minutes")
-        ]
-        
-        for idx, (label, value) in enumerate(info_data):
-            row = table.rows[idx]
-            row.cells[0].text = label
-            row.cells[1].text = value
-            row.cells[0].paragraphs[0].runs[0].bold = True
-            row.cells[0].paragraphs[0].runs[0].font.size = Pt(10)
-            row.cells[1].paragraphs[0].runs[0].font.size = Pt(10)
+        if question_type == "Multiple Choice Questions (MCQs)":
+            text = generate_mcqs(grade, subject, chapter, difficulty, num_questions)
+            questions, answers = parse_mcqs_and_answers(text, num_questions)
+            return questions, answers, None, None
         
-        # Instructions
-        doc.add_paragraph()
-        instructions = doc.add_paragraph()
-        instructions.add_run("INSTRUCTIONS:").bold = True
-        doc.add_paragraph("• Read each question carefully before selecting your answer")
-        doc.add_paragraph("• Each question carries equal marks")
-        doc.add_paragraph("• Select the MOST appropriate answer")
-        doc.add_paragraph("• Use the bubble sheet provided for marking answers")
-        
-        # Questions section
-        doc.add_paragraph()
-        questions_heading = doc.add_paragraph()
-        questions_heading.add_run("SECTION A: MULTIPLE CHOICE QUESTIONS").bold = True
-        questions_heading.runs[0].font.size = Pt(12)
-        doc.add_paragraph()
+        elif question_type == "Fill in the Blanks":
+            text = generate_fill_blanks(grade, subject, chapter, difficulty, num_questions)
+            questions, answers = parse_fill_blanks(text, num_questions)
+            return questions, answers, None, None
         
-        # Add MCQs
-        for i, q in enumerate(mcqs, start=1):
-            # Question number and stem
-            q_para = doc.add_paragraph()
-            q_para.add_run(f"Q{i}. ").bold = True
-            q_para.add_run(q)
-            q_para.space_after = Pt(6)
-            
-            doc.add_paragraph()
+        elif question_type == "Match the Column":
+            text = generate_match_column(grade, subject, chapter, difficulty, num_questions)
+            col_a, col_b, answers = parse_match_column(text)
+            return col_a, col_b, answers, None
         
-        # Answer key (on separate page)
-        doc.add_page_break()
+        elif question_type == "Short Response Questions":
+            text = generate_short_response(grade, subject, chapter, difficulty, num_questions)
+            questions, marking = parse_short_long_response(text, num_questions)
+            return questions, None, marking, None
         
-        ans_heading = doc.add_heading("ANSWER KEY", level=2)
-        ans_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        for run in ans_heading.runs:
-            run.font.color.rgb = RGBColor(153, 0, 0)
+        elif question_type == "Long Response Questions":
+            text = generate_long_response(grade, subject, chapter, difficulty, num_questions)
+            questions, marking = parse_short_long_response(text, num_questions)
+            return questions, None, marking, None
         
-        doc.add_paragraph("(For Teacher's Use Only)", style='Intense Quote')
+    except Exception as e:
+        return None, None, None, f"Error: {str(e)}"
+
+
+# ---------------------------
+# Enhanced DOCX Export Functions
+# ---------------------------
+def export_mcqs_to_word(questions, answers, grade, subject, chapter, difficulty, test_type, school_name, total_marks):
+    """Export MCQs to Word document"""
+    
+    doc = Document()
+    setup_document_style(doc)
+    add_header(doc, school_name, test_type)
+    add_info_table(doc, grade, subject, chapter, difficulty, total_marks, len(questions))
+    add_instructions(doc, "Select the MOST appropriate answer for each question")
+    
+    # Add questions
+    doc.add_paragraph()
+    heading = doc.add_paragraph()
+    heading.add_run("SECTION A: MULTIPLE CHOICE QUESTIONS").bold = True
+    heading.runs[0].font.size = Pt(12)
+    doc.add_paragraph()
+    
+    for i, q in enumerate(questions, 1):
+        q_para = doc.add_paragraph()
+        q_para.add_run(f"{i}. ").bold = True
+        q_para.add_run(q)
+        q_para.space_after = Pt(6)
+        doc.add_paragraph()
+    
+    # Add answer key
+    doc.add_page_break()
+    add_answer_key_mcq(doc, answers)
+    add_footer(doc)
+    
+    return save_document(doc, school_name, grade, subject, chapter, "MCQ")
+
+
+def export_fill_blanks_to_word(questions, answers, grade, subject, chapter, difficulty, test_type, school_name, total_marks):
+    """Export Fill in the Blanks to Word document"""
+    
+    doc = Document()
+    setup_document_style(doc)
+    add_header(doc, school_name, test_type)
+    add_info_table(doc, grade, subject, chapter, difficulty, total_marks, len(questions))
+    add_instructions(doc, "Fill in the blanks with appropriate words")
+    
+    # Add questions
+    doc.add_paragraph()
+    heading = doc.add_paragraph()
+    heading.add_run("SECTION A: FILL IN THE BLANKS").bold = True
+    heading.runs[0].font.size = Pt(12)
+    doc.add_paragraph()
+    
+    for i, q in enumerate(questions, 1):
+        q_para = doc.add_paragraph()
+        q_para.add_run(f"{i}. ").bold = True
+        q_para.add_run(q)
+        q_para.space_after = Pt(8)
+    
+    # Add answer key
+    doc.add_page_break()
+    add_answer_key_fill_blanks(doc, answers)
+    add_footer(doc)
+    
+    return save_document(doc, school_name, grade, subject, chapter, "FillBlanks")
+
+
+def export_match_column_to_word(col_a, col_b, answers, grade, subject, chapter, difficulty, test_type, school_name, total_marks):
+    """Export Match the Column to Word document"""
+    
+    doc = Document()
+    setup_document_style(doc)
+    add_header(doc, school_name, test_type)
+    add_info_table(doc, grade, subject, chapter, difficulty, total_marks, len(col_a))
+    add_instructions(doc, "Match items in Column A with Column B")
+    
+    # Add columns
+    doc.add_paragraph()
+    heading = doc.add_paragraph()
+    heading.add_run("SECTION A: MATCH THE COLUMN").bold = True
+    heading.runs[0].font.size = Pt(12)
+    doc.add_paragraph()
+    
+    # Create table
+    table = doc.add_table(rows=len(col_a) + 1, cols=3)
+    table.style = 'Light Grid Accent 1'
+    
+    # Headers
+    table.cell(0, 0).text = "COLUMN A"
+    table.cell(0, 1).text = "COLUMN B"
+    table.cell(0, 2).text = "Answer"
+    
+    for cell in table.rows[0].cells:
+        cell.paragraphs[0].runs[0].bold = True
+        cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
+    
+    # Fill data
+    for i in range(len(col_a)):
+        if i < len(col_a):
+            table.cell(i+1, 0).text = col_a[i]
+        if i < len(col_b):
+            table.cell(i+1, 1).text = col_b[i]
+        table.cell(i+1, 2).text = "____"
+    
+    # Add answer key
+    doc.add_page_break()
+    add_answer_key_match(doc, answers)
+    add_footer(doc)
+    
+    return save_document(doc, school_name, grade, subject, chapter, "MatchColumn")
+
+
+def export_response_to_word(questions, marking_guide, grade, subject, chapter, difficulty, test_type, school_name, total_marks, response_type):
+    """Export Short/Long Response questions to Word document"""
+    
+    doc = Document()
+    setup_document_style(doc)
+    add_header(doc, school_name, test_type)
+    add_info_table(doc, grade, subject, chapter, difficulty, total_marks, len(questions))
+    
+    if response_type == "Short":
+        add_instructions(doc, "Answer each question in 2-3 sentences")
+        section_title = "SECTION A: SHORT RESPONSE QUESTIONS"
+    else:
+        add_instructions(doc, "Answer each question in detail (1-2 paragraphs)")
+        section_title = "SECTION A: LONG RESPONSE QUESTIONS"
+    
+    # Add questions
+    doc.add_paragraph()
+    heading = doc.add_paragraph()
+    heading.add_run(section_title).bold = True
+    heading.runs[0].font.size = Pt(12)
+    doc.add_paragraph()
+    
+    for i, q in enumerate(questions, 1):
+        q_para = doc.add_paragraph()
+        q_para.add_run(f"{i}. ").bold = True
+        q_para.add_run(q)
+        q_para.space_after = Pt(10)
         
-        # Answer table with better formatting
-        num_rows = len(answers) + 1
-        ans_table = doc.add_table(rows=num_rows, cols=5)
-        ans_table.style = 'Medium Grid 1 Accent 1'
+        # Add answer space
+        doc.add_paragraph("_" * 80)
+        doc.add_paragraph("_" * 80)
+        if response_type == "Long":
+            doc.add_paragraph("_" * 80)
+            doc.add_paragraph("_" * 80)
+        doc.add_paragraph()
+    
+    # Add marking guide
+    doc.add_page_break()
+    add_marking_guide(doc, questions, marking_guide, response_type)
+    add_footer(doc)
+    
+    file_type = "ShortResponse" if response_type == "Short" else "LongResponse"
+    return save_document(doc, school_name, grade, subject, chapter, file_type)
+
+
+# ---------------------------
+# Document Helper Functions
+# ---------------------------
+def setup_document_style(doc):
+    """Setup document margins"""
+    sections = doc.sections
+    for section in sections:
+        section.top_margin = Inches(0.8)
+        section.bottom_margin = Inches(0.8)
+        section.left_margin = Inches(0.9)
+        section.right_margin = Inches(0.9)
+
+
+def add_header(doc, school_name, test_type):
+    """Add document header"""
+    if school_name and school_name.strip():
+        school_heading = doc.add_heading(school_name.upper(), level=0)
+        school_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        for run in school_heading.runs:
+            run.font.size = Pt(16)
+            run.font.color.rgb = RGBColor(0, 51, 102)
+    
+    test_title = doc.add_heading(f"{test_type.upper()}", level=1)
+    test_title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for run in test_title.runs:
+        run.bold = True
+        run.font.color.rgb = RGBColor(0, 102, 51)
+        run.font.size = Pt(16)
+
+
+def add_info_table(doc, grade, subject, chapter, difficulty, total_marks, num_questions):
+    """Add information table"""
+    table = doc.add_table(rows=7, cols=2)
+    table.style = 'Light Grid Accent 1'
+    
+    info_data = [
+        ("Grade:", grade),
+        ("Subject:", subject),
+        ("Chapter:", chapter),
+        ("Cognitive Level:", difficulty),
+        ("Total Marks:", str(total_marks)),
+        ("Date:", datetime.now().strftime("%d-%m-%Y")),
+        ("Duration:", "60 minutes" if num_questions > 15 else "40 minutes")
+    ]
+    
+    for idx, (label, value) in enumerate(info_data):
+        row = table.rows[idx]
+        row.cells[0].text = label
+        row.cells[1].text = value
+        row.cells[0].paragraphs[0].runs[0].bold = True
+        row.cells[0].paragraphs[0].runs[0].font.size = Pt(10)
+        row.cells[1].paragraphs[0].runs[0].font.size = Pt(10)
+
+
+def add_instructions(doc, instruction_text):
+    """Add instructions section"""
+    doc.add_paragraph()
+    instructions = doc.add_paragraph()
+    instructions.add_run("INSTRUCTIONS:").bold = True
+    doc.add_paragraph(f"• {instruction_text}")
+    doc.add_paragraph("• Read each question carefully")
+    doc.add_paragraph("• Write neatly and legibly")
+    doc.add_paragraph("• Manage your time effectively")
+
+
+def add_answer_key_mcq(doc, answers):
+    """Add MCQ answer key"""
+    ans_heading = doc.add_heading("ANSWER KEY", level=2)
+    ans_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for run in ans_heading.runs:
+        run.font.color.rgb = RGBColor(153, 0, 0)
+    
+    doc.add_paragraph("(For Teacher's Use Only)", style='Intense Quote')
+    
+    num_rows = len(answers) + 1
+    ans_table = doc.add_table(rows=num_rows, cols=5)
+    ans_table.style = 'Medium Grid 1 Accent 1'
+    
+    headers = ["Q#", "A", "B", "C", "D"]
+    for idx, header in enumerate(headers):
+        cell = ans_table.cell(0, idx)
+        cell.text = header
+        cell.paragraphs[0].runs[0].bold = True
+        cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
+    
+    for r, ans in enumerate(answers, start=1):
+        ans_table.cell(r, 0).text = str(r)
+        ans_table.cell(r, 0).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
         
-        # Headers
-        headers = ["Q#", "A", "B", "C", "D"]
-        for idx, header in enumerate(headers):
-            cell = ans_table.cell(0, idx)
-            cell.text = header
-            cell.paragraphs[0].runs[0].bold = True
+        for c, option in enumerate(["A", "B", "C", "D"], start=1):
+            cell = ans_table.cell(r, c)
+            if ans == option:
+                cell.text = "✓"
+                cell.paragraphs[0].runs[0].bold = True
+                cell.paragraphs[0].runs[0].font.color.rgb = RGBColor(0, 128, 0)
+                cell.paragraphs[0].runs[0].font.size = Pt(14)
+            else:
+                cell.text = ""
             cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
-        
-        # Fill answers
-        for r, ans in enumerate(answers, start=1):
-            ans_table.cell(r, 0).text = str(r)
-            ans_table.cell(r, 0).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
-            
-            for c, option in enumerate(["A", "B", "C", "D"], start=1):
-                cell = ans_table.cell(r, c)
-                if ans == option:
-                    cell.text = "✓"
-                    cell.paragraphs[0].runs[0].bold = True
-                    cell.paragraphs[0].runs[0].font.color.rgb = RGBColor(0, 128, 0)
-                    cell.paragraphs[0].runs[0].font.size = Pt(14)
-                else:
-                    cell.text = ""
-                cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
-        
-        # Footer
+
+
+def add_answer_key_fill_blanks(doc, answers):
+    """Add Fill in the Blanks answer key"""
+    ans_heading = doc.add_heading("ANSWER KEY", level=2)
+    ans_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for run in ans_heading.runs:
+        run.font.color.rgb = RGBColor(153, 0, 0)
+    
+    doc.add_paragraph("(For Teacher's Use Only)", style='Intense Quote')
+    
+    for i, ans in enumerate(answers, 1):
+        para = doc.add_paragraph()
+        para.add_run(f"{i}. ").bold = True
+        para.add_run(ans)
+
+
+def add_answer_key_match(doc, answers):
+    """Add Match the Column answer key"""
+    ans_heading = doc.add_heading("ANSWER KEY", level=2)
+    ans_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for run in ans_heading.runs:
+        run.font.color.rgb = RGBColor(153, 0, 0)
+    
+    doc.add_paragraph("(For Teacher's Use Only)", style='Intense Quote')
+    
+    para = doc.add_paragraph()
+    para.add_run("Correct Matches:\n").bold = True
+    para.add_run(", ".join(answers))
+
+
+def add_marking_guide(doc, questions, marking_guide, response_type):
+    """Add marking guide for response questions"""
+    guide_heading = doc.add_heading("MARKING GUIDE", level=2)
+    guide_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for run in guide_heading.runs:
+        run.font.color.rgb = RGBColor(153, 0, 0)
+    
+    doc.add_paragraph("(For Teacher's Use Only)", style='Intense Quote')
+    
+    for i, guide in enumerate(marking_guide, 1):
+        para = doc.add_paragraph()
+        para.add_run(f"Question {i}:\n").bold = True
+        para.add_run(guide)
         doc.add_paragraph()
-        footer = doc.add_paragraph()
-        footer.add_run(f"Generated by MCQ Test Generator v{APP_VERSION} | Developer: Najaf Ali Sharqi | {datetime.now().strftime('%d-%m-%Y %H:%M')}").italic = True
-        footer.runs[0].font.size = Pt(8)
-        footer.runs[0].font.color.rgb = RGBColor(128, 128, 128)
-        footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        
-        # Save file
-        safe_chapter = re.sub(r'[\\/*?:"<>|]', "_", chapter)
-        safe_school = re.sub(r'[\\/*?:"<>|]', "_", school_name) if school_name else "School"
-        filename = f"{safe_school}_{grade}_{subject}_{safe_chapter}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
-        
-        doc.save(filename)
-        return filename, None
-        
-    except Exception as e:
-        return None, f"Error creating document: {str(e)}"
+
+
+def add_footer(doc):
+    """Add document footer"""
+    doc.add_paragraph()
+    footer = doc.add_paragraph()
+    footer.add_run(f"Generated by Professional Test Generator v{APP_VERSION} | Developer: Najaf Ali Sharqi | {datetime.now().strftime('%d-%m-%Y %H:%M')}").italic = True
+    footer.runs[0].font.size = Pt(8)
+    footer.runs[0].font.color.rgb = RGBColor(128, 128, 128)
+    footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+
+def save_document(doc, school_name, grade, subject, chapter, doc_type):
+    """Save document with appropriate filename"""
+    safe_chapter = re.sub(r'[\\/*?:"<>|]', "_", chapter)
+    safe_school = re.sub(r'[\\/*?:"<>|]', "_", school_name) if school_name else "School"
+    filename = f"{safe_school}_{grade}_{subject}_{safe_chapter}_{doc_type}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
+    
+    doc.save(filename)
+    return filename
+
 
 # ---------------------------
-# Main generation handler
+# Main Generation Handler
 # ---------------------------
-def on_generate(grade, subject, chapter, difficulty, num_questions, test_type, school_name):
-    """Handle MCQ generation request"""
+def on_generate(question_type, grade, subject, chapter, difficulty, num_questions, test_type, school_name):
+    """Handle question generation request"""
     
     # Validation
-    if not all([grade, subject, chapter, difficulty]):
+    if not all([question_type, grade, subject, chapter, difficulty]):
         return "⚠️ Please fill all required fields", None, None
     
     if not school_name or not school_name.strip():
         school_name = "Educational Institution"
     
     try:
-        # Show progress
-        status_msg = f"🔄 Generating {num_questions} MCQs for {grade} {subject}...\n"
+        status_msg = f"🔄 Generating {num_questions} {question_type} for {grade} {subject}...\n"
         status_msg += f"📖 Chapter: {chapter}\n"
         status_msg += f"🎯 Cognitive Level: {difficulty}\n"
         status_msg += "⏳ Please wait..."
         
-        # Generate MCQs
-        mcqs, answers, error = generate_mcqs(
-            grade, subject, chapter, difficulty, 
-            num_questions, test_type, school_name
+        # Generate questions
+        result1, result2, result3, error = generate_questions(
+            question_type, grade, subject, chapter, difficulty, num_questions
         )
         
         if error:
             return f"❌ Error: {error}", None, None
         
-        if not mcqs or len(mcqs) == 0:
-            return "❌ No MCQs generated. Please try again.", None, None
-        
         # Calculate marks
-        total_marks = len(mcqs)
-        
-        # Export to Word
-        file_path, doc_error = export_to_word(
-            mcqs, answers, grade, subject, chapter, 
-            difficulty, test_type, school_name, total_marks
-        )
+        marks_per_q = QUESTION_TYPES[question_type]["marks_per_question"]
+        total_marks = len(result1) * marks_per_q if result1 else 0
         
-        if doc_error:
-            return f"❌ {doc_error}", None, None
+        # Export based on type
+        if question_type == "Multiple Choice Questions (MCQs)":
+            file_path = export_mcqs_to_word(
+                result1, result2, grade, subject, chapter,
+                difficulty, test_type, school_name, total_marks
+            )
+        elif question_type == "Fill in the Blanks":
+            file_path = export_fill_blanks_to_word(
+                result1, result2, grade, subject, chapter,
+                difficulty, test_type, school_name, total_marks
+            )
+        elif question_type == "Match the Column":
+            file_path = export_match_column_to_word(
+                result1, result2, result3, grade, subject, chapter,
+                difficulty, test_type, school_name, total_marks
+            )
+        elif question_type == "Short Response Questions":
+            file_path = export_response_to_word(
+                result1, result3, grade, subject, chapter,
+                difficulty, test_type, school_name, total_marks, "Short"
+            )
+        else:  # Long Response Questions
+            file_path = export_response_to_word(
+                result1, result3, grade, subject, chapter,
+                difficulty, test_type, school_name, total_marks, "Long"
+            )
         
         # Success message
         success_msg = f"✅ Test generated successfully!\n\n"
         success_msg += f"📊 Statistics:\n"
-        success_msg += f"• Total Questions: {len(mcqs)}\n"
+        success_msg += f"• Question Type: {question_type}\n"
+        success_msg += f"• Total Questions: {len(result1) if result1 else 0}\n"
+        success_msg += f"• Marks Per Question: {marks_per_q}\n"
         success_msg += f"• Total Marks: {total_marks}\n"
         success_msg += f"• Grade Level: {grade}\n"
         success_msg += f"• Subject: {subject}\n"
@@ -643,15 +1217,18 @@ def on_generate(grade, subject, chapter, difficulty, num_questions, test_type, s
         success_msg += f"📥 Download your test document below"
         
         # Preview
-        preview = "\n\n📝 PREVIEW (First 3 Questions):\n" + "="*50 + "\n\n"
-        for i, q in enumerate(mcqs[:3], 1):
-            preview += f"Q{i}. {q}\n\n"
+        if result1:
+            preview = "\n\n📝 PREVIEW (First 3 items):\n" + "="*50 + "\n\n"
+            for i, item in enumerate(result1[:3], 1):
+                preview += f"{i}. {item[:150]}...\n\n" if len(item) > 150 else f"{i}. {item}\n\n"
+            success_msg += preview
         
-        return success_msg + preview, file_path, f"🎉 File ready: {file_path}"
+        return success_msg, file_path, f"🎉 File ready: {file_path}"
         
     except Exception as e:
         return f"❌ Unexpected error: {str(e)}", None, None
 
+
 # ---------------------------
 # Enhanced Gradio UI
 # ---------------------------
@@ -668,22 +1245,24 @@ def create_ui():
         .description {text-align: center; color: #666; margin-bottom: 30px;}
         .footer {text-align: center; margin-top: 30px; padding: 20px; color: #888;}
         .warning {background-color: #fff3cd; padding: 10px; border-radius: 5px; margin: 10px 0;}
+        .info-box {background-color: #e7f3ff; padding: 15px; border-radius: 5px; margin: 10px 0;}
         """
     ) as demo:
         
         # Header
         gr.Markdown(
             """
-            # 📚 MCQ Test Generator Pro
-            ### Professional Assessment Tool Aligned with Pakistani National Curriculum (2006)
+            # 📚 Professional Test Generator Pro
+            ### Multi-Format Assessment Tool Aligned with Pakistani National Curriculum (2006)
             """,
             elem_classes="header"
         )
         
         gr.Markdown(
             """
-            Generate high-quality Multiple Choice Questions for educational assessments.
-            Based on Bloom's Taxonomy and best practices in item writing.
+            Generate high-quality assessment questions in multiple formats: MCQs, Fill in the Blanks,
+            Match the Column, Short Response, and Long Response Questions.
+            Based on Bloom's Taxonomy and professional item writing standards.
             """,
             elem_classes="description"
         )
@@ -699,10 +1278,29 @@ def create_ui():
                     info="Will appear on the test document header"
                 )
                 
+                question_type_dropdown = gr.Dropdown(
+                    choices=list(QUESTION_TYPES.keys()),
+                    value="Multiple Choice Questions (MCQs)",
+                    label="Question Type",
+                    info="Select the type of questions to generate"
+                )
+                
+                # Dynamic info box for question type
+                question_type_info = gr.Markdown(
+                    f"""
+                    <div class="info-box">
+                    <strong>📝 {list(QUESTION_TYPES.keys())[0]}</strong><br>
+                    {QUESTION_TYPES[list(QUESTION_TYPES.keys())[0]]['description']}<br>
+                    Marks per question: {QUESTION_TYPES[list(QUESTION_TYPES.keys())[0]]['marks_per_question']}
+                    </div>
+                    """,
+                    visible=True
+                )
+                
                 test_type = gr.Dropdown(
                     choices=[
                         "Weekly Test",
-                        "Monthly Test", 
+                        "Monthly Test",
                         "Mid-Term Examination",
                         "Final Examination",
                         "Practice Test",
@@ -724,9 +1322,9 @@ def create_ui():
                         minimum=5,
                         maximum=50,
                         value=20,
-                        step=5,
+                        step=1,
                         label="Number of Questions",
-                        info="How many MCQs to generate"
+                        info="How many questions to generate"
                     )
                 
                 subject_dropdown = gr.Dropdown(
@@ -748,7 +1346,6 @@ def create_ui():
                     info="Select cognitive complexity level"
                 )
                 
-                # Show description of selected difficulty
                 difficulty_info = gr.Markdown(
                     """
                     **Level Description:** Explain ideas or concepts
@@ -777,9 +1374,10 @@ def create_ui():
                 gr.Markdown(
                     """
                     ### 💡 Tips for Best Results:
+                    - Choose question type appropriate for learning objectives
                     - Select appropriate cognitive level for your students
                     - Review generated questions before final use
-                    - Combine multiple difficulty levels for comprehensive assessment
+                    - Mix different question types for comprehensive assessment
                     - Ensure chapter content has been taught before testing
                     """
                 )
@@ -790,7 +1388,7 @@ def create_ui():
                 output_text = gr.Textbox(
                     label="Generation Status & Preview",
                     lines=20,
-                    placeholder="Click 'Generate Test' to create MCQs...",
+                    placeholder="Click 'Generate Test' to create questions...",
                     interactive=False
                 )
                 
@@ -808,13 +1406,35 @@ def create_ui():
                 
                 gr.Markdown(
                     """
-                    ### 📄 Document Includes:
+                    ### 📄 Document Features:
                     - ✅ Professional header with school name
                     - ✅ Complete test information table
                     - ✅ Clear instructions for students
                     - ✅ Well-formatted questions
-                    - ✅ Separate answer key page
-                    - ✅ Marking grid for easy grading
+                    - ✅ Separate answer key/marking guide
+                    - ✅ Format-specific layouts
+                    
+                    ### 📚 Supported Question Types:
+                    
+                    **1. Multiple Choice Questions (MCQs)**
+                    - Four options with one correct answer
+                    - Ideal for knowledge and comprehension
+                    
+                    **2. Fill in the Blanks**
+                    - Tests recall and vocabulary
+                    - Quick to grade
+                    
+                    **3. Match the Column**
+                    - Tests relationships between concepts
+                    - Efficient assessment format
+                    
+                    **4. Short Response Questions**
+                    - Requires 2-3 sentence answers
+                    - Tests understanding and application
+                    
+                    **5. Long Response Questions**
+                    - Requires detailed paragraph answers
+                    - Tests analysis, evaluation, synthesis
                     """
                 )
         
@@ -823,7 +1443,8 @@ def create_ui():
             """
             ---
             <div class="footer">
-            <strong>MCQ Test Generator Pro v2.0</strong><br>
+            <strong>Professional Test Generator Pro v3.0</strong><br>
+            Multi-Format Assessment Tool<br>
             Aligned with Pakistani National Curriculum (2006)<br>
             Developer: <strong>Najaf Ali Sharqi</strong><br>
             Based on Bloom's Taxonomy & Professional Item Writing Standards<br><br>
@@ -835,21 +1456,18 @@ def create_ui():
         
         # Event handlers
         def update_subjects(selected_grade):
-            """Update subject dropdown when grade changes"""
             if selected_grade:
                 subjects = subjects_by_grade.get(selected_grade, [])
                 return gr.update(choices=subjects, value=None)
             return gr.update(choices=[], value=None)
         
         def update_chapters(selected_subject, selected_grade):
-            """Update chapter dropdown when subject or grade changes"""
             if selected_grade and selected_subject:
                 chapters = chapters_by_subject_and_grade.get(selected_grade, {}).get(selected_subject, [])
                 return gr.update(choices=chapters, value=None)
             return gr.update(choices=[], value=None)
         
         def update_difficulty_info(difficulty):
-            """Update difficulty level description"""
             if difficulty in DIFFICULTY_LEVELS:
                 info = DIFFICULTY_LEVELS[difficulty]
                 desc = info.get('description', '')
@@ -861,6 +1479,29 @@ def create_ui():
                 """
             return ""
         
+        def update_question_type_info(q_type):
+            if q_type in QUESTION_TYPES:
+                info = QUESTION_TYPES[q_type]
+                return f"""
+                <div class="info-box">
+                <strong>📝 {q_type}</strong><br>
+                {info['description']}<br>
+                Marks per question: {info['marks_per_question']}<br>
+                Recommended range: {info['min_questions']}-{info['max_questions']} questions
+                </div>
+                """
+            return ""
+        
+        def update_slider_range(q_type):
+            if q_type in QUESTION_TYPES:
+                info = QUESTION_TYPES[q_type]
+                return gr.update(
+                    minimum=info['min_questions'],
+                    maximum=info['max_questions'],
+                    value=info['default_questions']
+                )
+            return gr.update()
+        
         # Connect event handlers
         grade_dropdown.change(
             update_subjects,
@@ -886,9 +1527,22 @@ def create_ui():
             outputs=[difficulty_info]
         )
         
+        question_type_dropdown.change(
+            update_question_type_info,
+            inputs=[question_type_dropdown],
+            outputs=[question_type_info]
+        )
+        
+        question_type_dropdown.change(
+            update_slider_range,
+            inputs=[question_type_dropdown],
+            outputs=[num_questions]
+        )
+        
         generate_btn.click(
             on_generate,
             inputs=[
+                question_type_dropdown,
                 grade_dropdown,
                 subject_dropdown,
                 chapter_dropdown,
@@ -902,45 +1556,88 @@ def create_ui():
     
     return demo
 
+
 # ---------------------------
 # Launch application
 # ---------------------------
-try:
-    print("🚀 Starting MCQ Test Generator Pro v2.0")
-    print(f"📦 Gradio version: {gr.__version__}")
-    
-    # Check API key
-    if not GROQ_API_KEY:
-        print("⚠️ WARNING: GROQ_API_KEY not found in environment variables")
-        print("Please set it in Hugging Face Space Settings > Repository secrets")
-    else:
-        print(f"✅ API Key configured (length: {len(GROQ_API_KEY)})")
-    
-    # Create and launch
-    demo = create_ui()
-    print("✅ UI created successfully")
-    
-    demo.queue()  # Enable queue for better handling
-    demo.launch()
-    
-except Exception as e:
-    print(f"❌ Critical Error: {str(e)}")
-    import traceback
-    traceback.print_exc()
-    
-    # Create minimal error interface
-    with gr.Blocks() as error_demo:
-        gr.Markdown(f"""
-        # ❌ Application Error
+if __name__ == "__main__":
+    try:
+        print("🚀 Starting Professional Test Generator Pro v3.0")
+        print(f"📦 Gradio version: {gr.__version__}")
+        
+        # Check API key
+        if not GROQ_API_KEY:
+            print("⚠️ WARNING: GROQ_API_KEY not found in environment variables")
+            print("Please set it in Hugging Face Space Settings > Repository secrets")
+        else:
+            print(f"✅ API Key configured (length: {len(GROQ_API_KEY)})")
         
-        **Error Message:** {str(e)}
+        # Create and launch
+        demo = create_ui()
+        print("✅ UI created successfully")
         
-        **Common Solutions:**
-        1. Check if GROQ_API_KEY is set in Space settings
-        2. Verify all dependencies are installed
-        3. Check the build logs for errors
+        demo.queue()
+        demo.launch()
+        
+    except Exception as e:
+        print(f"❌ Critical Error: {str(e)}")
+        import traceback
+        traceback.print_exc()
         
+        # Create minimal error interface
+        with gr.Blocks() as error_demo:
+            gr.Markdown(f"""
+            # ❌ Application Error
+            
+            **Error Message:** {str(e)}
+            
+            **Common Solutions:**
+            1. Check if GROQ_API_KEY is set in Space settings
+            2. Verify all dependencies are installed
+            3. Check the build logs for errors
         **Contact:** Developer - Najaf Ali Sharqi
         """)
     
-    error_demo.launch()
+    error_demo.launch()
+
+## Complete! 🎉
+
+This is the **complete, production-ready code** with all features:
+
+### ✅ Key Features Implemented:
+
+1. **5 Question Types:**
+   - Multiple Choice Questions (MCQs)
+   - Fill in the Blanks
+   - Match the Column
+   - Short Response Questions
+   - Long Response Questions
+
+2. **Fixed Parsing Issues:**
+   - Removes introductory text like "Here are the MCQs..."
+   - Starts directly with actual questions
+   - Robust regex parsing for all formats
+
+3. **Professional Documents:**
+   - Format-specific layouts
+   - Answer keys/marking guides
+   - Professional styling
+
+4. **Dynamic UI:**
+   - Question type selector with info boxes
+   - Dynamic slider ranges based on question type
+   - Real-time updates
+
+### 📦 Requirements (`requirements.txt`):
+gradio>=4.0.0
+groq>=0.4.0
+python-docx>=0.8.11
+
+### 🚀 Deployment Steps:
+1. Create new Hugging Face Space
+2. Upload this `app.py`
+3. Create `requirements.txt` with above content
+4. Set `GROQ_API_KEY` in Space secrets
+5. Deploy!
+
+The app is ready for production use! 🎯