Update app.py

app.py

@@ -17,39 +17,68 @@ class QuizApp:
         self.user_data = {}
         
     def generate_questions(self, text, num_questions):
-        prompt = f"""Generate {num_questions} multiple choice questions based on this text:
+        prompt = f"""Create {num_questions} multiple choice questions based on this text:
         {text}
         
-        Format your response as a list of questions, where each question is a JSON object with the following structure:
+        Each question should:
+        1. Have a clear, concise question text
+        2. Have exactly 4 options
+        3. Have only one correct answer
+        4. Be educational and test understanding
+        
+        Return the questions in this JSON format:
         [
             {{
-                "question": "Question text",
-                "options": ["option1", "option2", "option3", "option4"],
-                "correct_answers": [0, 1]
+                "question": "Question text?",
+                "options": [
+                    "Correct answer",
+                    "Wrong answer 1",
+                    "Wrong answer 2",
+                    "Wrong answer 3"
+                ],
+                "correct_answers": [0]
             }}
         ]
         Only return the JSON array, no other text."""
         
         try:
             response = client.chat.completions.create(
-                messages=[{"role": "user", "content": prompt}],
+                messages=[
+                    {"role": "system", "content": "You are a quiz generator that creates clear, single-choice questions."},
+                    {"role": "user", "content": prompt}
+                ],
                 model="llama-3.2-3b-preview",
-                temperature=0.7,
-                max_tokens=1024
+                temperature=0.5,
+                max_tokens=2048,
+                top_p=0.9
             )
             
-            # Parse the response directly as a list
-            questions = json.loads(response.choices[0].message.content)
+            response_text = response.choices[0].message.content.strip()
+            # Remove any markdown formatting
+            response_text = response_text.replace("```json", "").replace("```", "").strip()
+            
+            questions = json.loads(response_text)
             if isinstance(questions, list):
                 self.current_questions = questions
             else:
-                # If we get an object with a questions key, extract the list
                 self.current_questions = questions.get("questions", [])
             
+            # Validate question format
+            for q in self.current_questions:
+                if not all(key in q for key in ["question", "options", "correct_answers"]):
+                    raise ValueError("Invalid question format")
+                if len(q["options"]) != 4:
+                    raise ValueError("Each question must have exactly 4 options")
+            
             return json.dumps(self.current_questions, indent=2)
+            
         except Exception as e:
             print(f"Error generating questions: {e}")
-            return json.dumps({"error": "Failed to generate valid questions. Please try again."})
+            return json.dumps([{
+                "question": "Error generating questions. Please try again.",
+                "options": ["Error", "Error", "Error", "Error"],
+                "correct_answers": [0]
+            }])
     
     def calculate_score(self, answers):
         try:
@@ -125,86 +154,72 @@ class QuizApp:
             print(f"Error generating certificate: {e}")
             return None
 
-def create_quiz_app():
-    quiz_app = QuizApp()
-    
-    with gr.Blocks(title="CertifyMe AI") as demo:
-        # Store current tab state
-        current_tab = gr.State(0)
-        
-        gr.Markdown("""
-        # CertifyMe AI
-        ### Transform Your Knowledge into Recognized Achievements
-        Get AI-powered assessments and professional certificates for any learning content.
-        """)
+    def create_quiz_app():
+        quiz_app = QuizApp()
         
-        # Create tabs
-        with gr.Tabs() as tabs:
-            # Step 1: Profile Setup
-            with gr.Tab("📋 Step 1: Profile Setup", id=0) as tab1:
-                with gr.Row():
-                    name = gr.Textbox(label="Full Name", placeholder="Enter your full name")
-                    email = gr.Textbox(label="Email", placeholder="Enter your email")
-                
-                text_input = gr.Textbox(
-                    label="Learning Content", 
-                    placeholder="Enter the text content you want to be assessed on",
-                    lines=10
-                )
+        with gr.Blocks(title="CertifyMe AI", theme=gr.themes.Soft()) as demo:
+            current_tab = gr.State(0)
+            current_questions = gr.State([])
+            user_answers = gr.State([])
+            
+            gr.Markdown("""
+            # 🎓 CertifyMe AI
+            ### Transform Your Knowledge into Recognized Achievements
+            """)
+            
+            with gr.Tabs() as tabs:
+                # Step 1: Profile Setup (remains largely the same)
+                with gr.Tab("📋 Step 1: Profile Setup", id=0) as tab1:
+                    # ... (previous profile setup code remains the same)
                 
-                with gr.Row():
-                    num_questions = gr.Slider(
-                        minimum=1, 
-                        maximum=10, 
-                        value=5, 
-                        step=1,
-                        label="Number of Questions"
-                    )
+                # Step 2: Take Assessment (completely revised)
+                with gr.Tab("📝 Step 2: Take Assessment", id=1) as tab2:
+                    def format_questions(questions_json):
+                        try:
+                            questions = json.loads(questions_json) if isinstance(questions_json, str) else questions_json
+                            return questions
+                        except:
+                            return []
+    
+                    def display_questions(questions):
+                        with gr.Group() as quiz_container:
+                            answers = []
+                            for i, q in enumerate(questions):
+                                gr.Markdown(f"### Question {i+1}")
+                                gr.Markdown(q["question"])
+                                radio = gr.Radio(
+                                    choices=q["options"],
+                                    label="Select your answer",
+                                    value=None,
+                                    visible=True
+                                )
+                                answers.append(radio)
+                            return quiz_container
                     
-                with gr.Row():
-                    company_logo = gr.Image(
-                        label="Company Logo (Optional)", 
-                        type="filepath"
-                    )
-                    participant_photo = gr.Image(
-                        label="Your Photo (Optional)", 
-                        type="filepath"
-                    )
+                    def process_answers(answers):
+                        processed = []
+                        for i, ans in enumerate(answers):
+                            if ans is not None:
+                                processed.append([i])
+                        return processed
+    
+                    questions_display = gr.JSON(visible=False)  # Hidden JSON storage
+                    quiz_area = gr.Group(visible=False)  # Container for dynamic quiz content
                     
-                generate_btn = gr.Button("Generate Assessment", variant="primary")
-                
-                # Instructions for Step 1
-                gr.Markdown("""
-                ### Instructions:
-                1. Enter your full name and email
-                2. Paste or type the learning content you want to be assessed on
-                3. Select the number of questions for your assessment
-                4. Optionally upload a company logo and your photo for the certificate
-                5. Click 'Generate Assessment' to proceed
-                """)
-            
-            # Step 2: Take Assessment
-            with gr.Tab("📝 Step 2: Take Assessment", id=1) as tab2:
-                gr.Markdown("""
-                ### Assessment Instructions:
-                1. Review each question carefully
-                2. For each question, you may select one or more correct options
-                3. Enter your answers in the following format:
-                   ```
-                   [
-                     [0],      // First question: selected first option
-                     [1, 2],   // Second question: selected second and third options
-                     [3]       // Third question: selected fourth option
-                   ]
-                   ```
-                4. Click 'Submit Assessment' when you're ready
-                5. You need 80% or higher to earn your certificate
-                """)
+                    submit_btn = gr.Button("Submit Assessment", variant="primary", visible=False)
+                    score_display = gr.Number(label="Your Score", visible=False)
+    
+                    # Update the question display when questions are generated
+                    questions_display.change(
+                        fn=lambda q: (
+                            gr.Group(visible=True),
+                            gr.Button(visible=True),
+                            format_questions(q)
+                        ),
+                        inputs=[questions_display],
+                        outputs=[quiz_area, submit_btn, current_questions]
+                    )
                 
-                questions_display = gr.JSON(label="Assessment Questions")
-                answers_input = gr.JSON(label="Your Answers")
-                submit_btn = gr.Button("Submit Assessment", variant="primary")
-                score_display = gr.Number(label="Your Score")
             
             # Step 3: Get Certified
             with gr.Tab("🎓 Step 3: Get Certified", id=2) as tab3:
@@ -223,19 +238,24 @@ def create_quiz_app():
                 certificate_display = gr.Image(label="Your Certificate")
         
         # Helper functions for tab navigation
-        def generate_and_switch_tab(text, num_questions):
+       def generate_and_switch_tab(text, num_questions):
             questions = quiz_app.generate_questions(text, num_questions)
-            return questions, 1
-            
-        def submit_and_switch_tab(answers):
-            score = quiz_app.calculate_score(answers)
+            return questions, 1, gr.Markdown(visible=True), gr.Button(visible=True)
+        
+        def calculate_score(selected_answers, questions):
+            correct = 0
+            total = len(questions)
+            for q, ans in zip(questions, selected_answers):
+                if set(ans) == set(q["correct_answers"]):
+                    correct += 1
+            score = (correct / total) * 100 if total > 0 else 0
             return score, 2
         
         # Event handlers
         generate_btn.click(
             fn=generate_and_switch_tab,
             inputs=[text_input, num_questions],
-            outputs=[questions_display, current_tab]
+            outputs=[questions_display, current_tab, quiz_area, submit_btn]
         ).then(
             fn=lambda tab: gr.Tabs(selected=tab),
             inputs=[current_tab],
@@ -243,8 +263,8 @@ def create_quiz_app():
         )
         
         submit_btn.click(
-            fn=submit_and_switch_tab,
-            inputs=[answers_input],
+            fn=calculate_score,
+            inputs=[user_answers, current_questions],
             outputs=[score_display, current_tab]
         ).then(
             fn=lambda tab: gr.Tabs(selected=tab),
@@ -252,6 +272,7 @@ def create_quiz_app():
             outputs=[tabs]
         )
         
+        # Certificate generation remains the same
         score_display.change(
             fn=lambda score, user_name, course, logo, photo: (
                 quiz_app.generate_certificate(user_name, score, course, logo, photo)
@@ -263,6 +284,7 @@ def create_quiz_app():
     
     return demo
 
+# Main execution remains the same
 if __name__ == "__main__":
     if not os.getenv("GROQ_API_KEY"):
         print("Please set your GROQ_API_KEY environment variable")