Update app.py

app.py

@@ -33,7 +33,8 @@ class QuizGenerator:
                 messages=[
                     {
                         "role": "system",
-                        "content": "You are a quiz generator. Create clear questions with concise answer options."
+                        "content": """You are a quiz generator. Create clear questions with concise answer options.
+                        Always return valid JSON array of questions. Format answers as short, clear phrases."""
                     },
                     {
                         "role": "user",
@@ -49,68 +50,105 @@ class QuizGenerator:
             return self._validate_questions(questions, num_questions)
             
         except Exception as e:
+            print(f"Error in generate_questions: {str(e)}")
+            print(f"Response content: {response.choices[0].message.content if response else 'No response'}")
             raise QuizGenerationError(f"Failed to generate questions: {str(e)}")
     
     def _create_prompt(self, text: str, num_questions: int) -> str:
-        return f"""Create exactly {num_questions} multiple choice questions based on this text:
-        {text}
-        
-        For each question:
-        1. Create a clear, concise question
-        2. Provide exactly 4 options
-        3. Mark the correct answer with the index (0-3)
-        4. Ensure options are concise and clear
-        
-        Return ONLY a JSON array with this EXACT format - no other text:
-        [
-            {{
-                "question": "Question text here?",
-                "options": [
-                    "Brief option 1",
-                    "Brief option 2",
-                    "Brief option 3",
-                    "Brief option 4"
-                ],
-                "correct_answer": 0
-            }}
-        ]
-        Keep all options concise (10 words or less each).
-        """
+        return f"""Generate exactly {num_questions} multiple choice questions based on the following text. Follow these rules strictly:
+
+1. Each question must be clear and focused
+2. Provide exactly 4 options for each question
+3. Mark the correct answer with index (0-3)
+4. Keep all options concise (under 10 words)
+5. Return ONLY a JSON array with this exact format:
+[
+    {{
+        "question": "Clear question text here?",
+        "options": [
+            "Brief option 1",
+            "Brief option 2",
+            "Brief option 3",
+            "Brief option 4"
+        ],
+        "correct_answer": 0
+    }}
+]
+
+Text to generate questions from:
+{text}
+
+Important: Return only the JSON array, no other text or formatting."""
     
     def _parse_response(self, response_text: str) -> List[Dict]:
-        response_text = response_text.replace("```json", "").replace("```", "").strip()
-        start_idx = response_text.find("[")
-        end_idx = response_text.rfind("]")
-        
-        if start_idx == -1 or end_idx == -1:
-            raise ValueError("No valid JSON array found in response")
+        """Parse response with improved error handling"""
+        try:
+            # Clean up the response text
+            cleaned_text = response_text.strip()
+            cleaned_text = cleaned_text.replace('```json', '').replace('```', '').strip()
+            
+            # Find the JSON array
+            start_idx = cleaned_text.find('[')
+            end_idx = cleaned_text.rfind(']')
+            
+            if start_idx == -1 or end_idx == -1:
+                raise ValueError("No valid JSON array found in response")
+            
+            json_text = cleaned_text[start_idx:end_idx + 1]
             
-        response_text = response_text[start_idx:end_idx + 1]
-        return json.loads(response_text)
+            # Attempt to parse the JSON
+            try:
+                return json.loads(json_text)
+            except json.JSONDecodeError as e:
+                print(f"JSON Parse Error: {str(e)}")
+                print(f"Attempted to parse: {json_text}")
+                raise
+                
+        except Exception as e:
+            print(f"Error parsing response: {str(e)}")
+            print(f"Original response: {response_text}")
+            raise ValueError(f"Failed to parse response: {str(e)}")
     
     def _validate_questions(self, questions: List[Dict], num_questions: int) -> List[Question]:
+        """Validate questions with improved error checking"""
         validated = []
+        
         for q in questions:
-            if not self._is_valid_question(q):
+            try:
+                if not self._is_valid_question(q):
+                    print(f"Invalid question format: {q}")
+                    continue
+                    
+                validated.append(Question(
+                    question=q["question"].strip(),
+                    options=[str(opt).strip()[:100] for opt in q["options"]],
+                    correct_answer=int(q["correct_answer"]) % 4
+                ))
+            except Exception as e:
+                print(f"Error validating question: {str(e)}")
                 continue
-            validated.append(Question(
-                question=q["question"].strip(),
-                options=[opt.strip()[:100] for opt in q["options"]],
-                correct_answer=int(q["correct_answer"]) % 4
-            ))
         
         if not validated:
             raise ValueError("No valid questions after validation")
-            
+        
         return validated[:num_questions]
     
     def _is_valid_question(self, question: Dict) -> bool:
-        return (
-            all(key in question for key in ["question", "options", "correct_answer"]) and
-            isinstance(question["options"], list) and
-            len(question["options"]) == 4 and
-            all(isinstance(opt, str) for opt in question["options"])
-        )
+        """Check if question format is valid"""
+        try:
+            return (
+                isinstance(question, dict) and
+                all(key in question for key in ["question", "options", "correct_answer"]) and
+                isinstance(question["question"], str) and
+                isinstance(question["options"], list) and
+                len(question["options"]) == 4 and
+                all(isinstance(opt, str) for opt in question["options"]) and
+                isinstance(question["correct_answer"], (int, str)) and
+                int(question["correct_answer"]) in range(4)
+            )
+        except Exception as e:
+            print(f"Question validation error: {str(e)}")
+            return False
 
 class FontManager:
     """Manages font installation and loading for the certificate generator"""