Update app.py

app.py

@@ -1,45 +1,43 @@
 """
-Enhanced Gradio application with more dynamic question configuration
+Main Gradio application optimized for Hugging Face Spaces
 """
 
 import gradio as gr
 import os
 import tempfile
+import json
 from multi_agent import MultiAgentSystem
 from docx_builder import generate_all_documents
 
 # Initialize the multi-agent system
 agent_system = MultiAgentSystem()
 
-def generate_exam_package(subject, stream, part_a_count, part_b_count, part_c_count, 
-                         part_a_marks, part_b_marks, part_c_marks, syllabus_file, reference_file):
-    """Enhanced main function with dynamic marks configuration"""
+def generate_exam_package(subject, stream, part_a_count, part_b_count, part_c_count, syllabus_file, reference_file):
+    """Main function called by Gradio interface"""
     
     try:
-        # Convert counts and marks to integers
-        part_a_count = int(part_a_count)
-        part_b_count = int(part_b_count) 
-        part_c_count = int(part_c_count)
-        part_a_marks = int(part_a_marks)
-        part_b_marks = int(part_b_marks)
-        part_c_marks = int(part_c_marks)
+        # Convert counts to integers
+        part_a_count = int(part_a_count) if part_a_count else 5
+        part_b_count = int(part_b_count) if part_b_count else 5
+        part_c_count = int(part_c_count) if part_c_count else 1
         
-        # Generate exam package with dynamic marks
+        # Validate inputs
+        if not subject or not syllabus_file:
+            return None, None, None, "❌ Please provide subject name and syllabus PDF"
+        
+        # Generate exam package
         final_output, status = agent_system.generate_exam_package(
             subject=subject,
             stream=stream,
             part_a_count=part_a_count,
             part_b_count=part_b_count,
             part_c_count=part_c_count,
-            part_a_marks=part_a_marks,
-            part_b_marks=part_b_marks, 
-            part_c_marks=part_c_marks,
             syllabus_file=syllabus_file,
             reference_file=reference_file
         )
         
         if status != "Success":
-            return None, None, None, status
+            return None, None, None, f"❌ {status}"
         
         # Create temporary directory for outputs
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -47,173 +45,182 @@ def generate_exam_package(subject, stream, part_a_count, part_b_count, part_c_co
             files = generate_all_documents(final_output, subject, stream, temp_dir)
             
             # Return file paths
-            return files["question_paper"], files["answer_key"], files["obe_summary"], "Generation completed successfully!"
+            return files["question_paper"], files["answer_key"], files["obe_summary"], "✅ Generation completed successfully!"
     
     except Exception as e:
-        error_msg = f"Error: {str(e)}"
+        error_msg = f"❌ Error: {str(e)}"
         print(error_msg)
         return None, None, None, error_msg
 
 def update_progress_ui():
     """Update progress in UI"""
     progress = agent_system.get_progress()
-    return f"{progress['stage'].upper()}: {progress['message']} ({progress['percentage']}%)"
+    return f"🔄 {progress['stage'].upper()}: {progress['message']} ({progress['percentage']}%)"
 
-def calculate_total_marks(part_a_count, part_b_count, part_c_count, part_a_marks, part_b_marks, part_c_marks):
-    """Calculate and display total marks in real-time"""
+def validate_inputs(subject, part_a_count, part_b_count, part_c_count):
+    """Validate user inputs"""
+    errors = []
+    if not subject:
+        errors.append("Subject name is required")
+    
     try:
-        total = (int(part_a_count) * int(part_a_marks)) + (int(part_b_count) * int(part_b_marks)) + (int(part_c_count) * int(part_c_marks))
-        return f"📊 Total Marks: {total}"
+        if part_a_count and int(part_a_count) <= 0:
+            errors.append("Part A count must be positive")
+        if part_b_count and int(part_b_count) <= 0:
+            errors.append("Part B count must be positive") 
+        if part_c_count and int(part_c_count) <= 0:
+            errors.append("Part C count must be positive")
     except:
-        return "📊 Total Marks: 0"
+        errors.append("Question counts must be numbers")
+    
+    return errors
 
-# Enhanced Gradio interface
+# Gradio interface
 with gr.Blocks(title="AI Exam Generator", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚀 AI-Powered Question Paper & Answer Generator")
-    gr.Markdown("Generate complete exam packages with OBE compliance using multi-agent AI system")
+    gr.Markdown("""
+    # 🚀 AI-Powered Question Paper Generator
+    *Generate complete exam packages with OBE compliance using multi-agent AI system*
+    """)
     
     with gr.Row():
-        with gr.Column():
+        with gr.Column(scale=1):
             # Input section
+            gr.Markdown("### 📝 Exam Configuration")
+            
             subject_name = gr.Textbox(
                 label="Subject Name",
-                placeholder="e.g., Data Structures, Thermodynamics, Digital Electronics",
+                placeholder="e.g., Data Structures, Algorithms, Database Systems",
                 value="Data Structures"
             )
             
             stream = gr.Dropdown(
                 choices=["CSE", "Non-CSE"],
-                label="Stream",
-                value="CSE"
+                label="Engineering Stream",
+                value="CSE",
+                info="CSE: Company tags | Non-CSE: GATE patterns"
             )
             
-            # Enhanced question configuration with marks
-            with gr.Group():
-                gr.Markdown("### Part A Configuration")
-                with gr.Row():
-                    part_a_count = gr.Number(
-                        label="Number of Questions",
-                        value=5,
-                        minimum=1,
-                        maximum=50,
-                        step=1
-                    )
-                    part_a_marks = gr.Number(
-                        label="Marks per Question",
-                        value=2,
-                        minimum=1, 
-                        maximum=10,
-                        step=1
-                    )
-            
-            with gr.Group():
-                gr.Markdown("### Part B Configuration")
-                with gr.Row():
-                    part_b_count = gr.Number(
-                        label="Number of Questions",
-                        value=5,
-                        minimum=1,
-                        maximum=20,
-                        step=1
-                    )
-                    part_b_marks = gr.Number(
-                        label="Marks per Question", 
-                        value=13,
-                        minimum=5,
-                        maximum=20,
-                        step=1
-                    )
-            
-            with gr.Group():
-                gr.Markdown("### Part C Configuration")
-                with gr.Row():
-                    part_c_count = gr.Number(
-                        label="Number of Questions",
-                        value=1,
-                        minimum=1,
-                        maximum=5,
-                        step=1
-                    )
-                    part_c_marks = gr.Number(
-                        label="Marks per Question",
-                        value=14,
-                        minimum=10,
-                        maximum=30,
-                        step=1
-                    )
-            
-            # Total marks display
-            total_marks_display = gr.Textbox(
-                label="Marks Summary",
-                value="📊 Total Marks: 0",
-                interactive=False
-            )
+            with gr.Row():
+                part_a_count = gr.Number(
+                    label="Part A Questions",
+                    value=5,
+                    minimum=1,
+                    maximum=20,
+                    info="2 marks each"
+                )
+                
+                part_b_count = gr.Number(
+                    label="Part B Questions", 
+                    value=5,
+                    minimum=1,
+                    maximum=10,
+                    info="13 marks each"
+                )
+                
+                part_c_count = gr.Number(
+                    label="Part C Questions",
+                    value=1,
+                    minimum=1,
+                    maximum=3,
+                    info="14 marks each"
+                )
             
             syllabus_pdf = gr.File(
-                label="Syllabus PDF",
+                label="Upload Syllabus PDF",
                 file_types=[".pdf"],
-                type="filepath"
+                type="filepath",
+                file_count="single"
             )
             
             reference_qp = gr.File(
-                label="Reference Question Paper PDF (Optional)",
+                label="Reference Question Paper (Optional)",
                 file_types=[".pdf"],
-                type="filepath"
+                type="filepath",
+                file_count="single"
             )
             
-            generate_btn = gr.Button("Generate Exam Package", variant="primary", size="lg")
+            generate_btn = gr.Button("🎯 Generate Exam Package", variant="primary", size="lg")
         
-        with gr.Column():
+        with gr.Column(scale=1):
             # Output section
+            gr.Markdown("### 📤 Generated Outputs")
+            
             status_display = gr.Textbox(
-                label="Generation Status",
-                value="Ready to generate",
-                interactive=False
+                label="Status",
+                value="🟢 Ready to generate exam package",
+                interactive=False,
+                lines=2
             )
             
-            with gr.Row():
-                qp_download = gr.File(
-                    label="Question Paper (.docx)",
-                    file_types=[".docx"],
-                    interactive=False
-                )
-                
-                answers_download = gr.File(
-                    label="Answer Key (.docx)", 
-                    file_types=[".docx"],
-                    interactive=False
-                )
-                
-                obe_download = gr.File(
-                    label="OBE Summary (.docx)",
-                    file_types=[".docx"],
-                    interactive=False
-                )
+            with gr.Group():
+                gr.Markdown("#### 📄 Download Files")
+                with gr.Row():
+                    qp_download = gr.File(
+                        label="Question Paper",
+                        file_types=[".docx"],
+                        interactive=False,
+                        visible=False
+                    )
+                    
+                    answers_download = gr.File(
+                        label="Answer Key",
+                        file_types=[".docx"],
+                        interactive=False, 
+                        visible=False
+                    )
+                    
+                    obe_download = gr.File(
+                        label="OBE Summary",
+                        file_types=[".docx"],
+                        interactive=False,
+                        visible=False
+                    )
     
     # Progress section
+    gr.Markdown("### 🔄 Generation Progress")
     progress_text = gr.Textbox(
         label="Real-time Progress",
-        value="System ready",
+        value="🟢 System initialized and ready",
         interactive=False,
-        every=2
+        every=1
     )
     
-    # Event handlers for real-time calculations
-    inputs_for_calculation = [part_a_count, part_b_count, part_c_count, part_a_marks, part_b_marks, part_c_marks]
+    # Instructions
+    gr.Markdown("""
+    ## 📖 How to Use This System
     
-    for input_component in inputs_for_calculation:
-        input_component.change(
-            fn=calculate_total_marks,
-            inputs=inputs_for_calculation,
-            outputs=[total_marks_display]
-        )
+    1. **Enter Subject Details**: Provide the subject name and select engineering stream
+    2. **Configure Questions**: Set the number of questions for each part (A, B, C)
+    3. **Upload Syllabus**: PDF file containing course syllabus and learning outcomes
+    4. **Optional Reference**: Upload previous question papers for style reference
+    5. **Generate**: Click the button to create your complete exam package
+    6. **Download**: Get all three DOCX files (Question Paper, Answer Key, OBE Summary)
+    
+    ## 🎯 Features
+    
+    - **🤖 Multi-Agent AI**: Three specialized agents for generation, verification, and formatting
+    - **📊 OBE Compliant**: Automatic Outcome-Based Education reporting
+    - **🔄 Real-time Updates**: Incorporates recent developments in the field
+    - **🎓 Stream-specific**: CSE (company tags) vs Non-CSE (GATE patterns)
+    - **✅ Quality Verified**: Automated validation of standards and requirements
+    - **📝 Professional Output**: Ready-to-use DOCX files with proper formatting
+    
+    ## ⚠️ Important Notes
+    
+    - Ensure your syllabus PDF is readable and contains clear learning outcomes
+    - For best results, provide a descriptive subject name
+    - The system works without API keys but with enhanced capabilities when configured
+    - Generation may take 1-2 minutes depending on complexity
+    """)
     
-    # Main generation handler
+    # Event handlers
     generate_btn.click(
         fn=generate_exam_package,
-        inputs=[subject_name, stream, part_a_count, part_b_count, part_c_count, 
-                part_a_marks, part_b_marks, part_c_marks, syllabus_pdf, reference_qp],
+        inputs=[subject_name, stream, part_a_count, part_b_count, part_c_count, syllabus_pdf, reference_qp],
         outputs=[qp_download, answers_download, obe_download, status_display]
+    ).then(
+        fn=lambda: (gr.File(visible=True), gr.File(visible=True), gr.File(visible=True)),
+        outputs=[qp_download, answers_download, obe_download]
     )
     
     # Progress updates
@@ -223,6 +230,13 @@ with gr.Blocks(title="AI Exam Generator", theme=gr.themes.Soft()) as demo:
         outputs=[progress_text]
     )
 
+# Deployment configuration
 if __name__ == "__main__":
-    demo.queue(concurrency_count=1)
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    # For Hugging Face Spaces
+    demo.queue(concurrency_count=1, max_size=10)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )