Update app.py

app.py

@@ -24,131 +24,158 @@ class QuizFeedback:
 class QuizGenerator:
     def __init__(self, api_key: str):
         self.client = Groq(api_key=api_key)
-    
+        
     def generate_questions(self, text: str, num_questions: int) -> List[Question]:
+        """Generate quiz questions from input text"""
         prompt = self._create_prompt(text, num_questions)
         
         try:
+            # Make API request with improved error handling
             response = self.client.chat.completions.create(
                 messages=[
                     {
                         "role": "system",
-                        "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."""
+                        "content": """You are a quiz generator. Generate multiple choice questions based on the given text.
+                        Each question must have exactly 4 options and one correct answer.
+                        Return ONLY a valid JSON array of questions in the specified format.
+                        Make questions clear, focused and directly related to the input text.
+                        Avoid subjective or ambiguous questions."""
                     },
                     {
                         "role": "user",
                         "content": prompt
                     }
                 ],
-                model="llama-3.2-3b-preview",
-                temperature=0,
-                max_tokens=2048
+                model="llama2-70b-4096",  # Using a more capable model
+                temperature=0.2,  # Lower temperature for more consistent output
+                max_tokens=2048,
+                stop=None  # Let the model complete its output
             )
             
+            if not response or not response.choices or not response.choices[0].message.content:
+                raise ValueError("Empty response from API")
+                
+            # Parse and validate response
             questions = self._parse_response(response.choices[0].message.content)
-            return self._validate_questions(questions, num_questions)
+            validated = self._validate_questions(questions, num_questions)
+            
+            if not validated:
+                raise ValueError("No valid questions generated")
+                
+            return validated
             
         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'}")
+            print(f"Full error details: ", {
+                "error": str(e),
+                "response": getattr(response, 'choices', [{}])[0].get('message', {}).get('content', 'No content')
+                if 'response' in locals() else 'No response'
+            })
             raise QuizGenerationError(f"Failed to generate questions: {str(e)}")
     
     def _create_prompt(self, text: str, num_questions: int) -> str:
-        return f"""Generate exactly {num_questions} multiple choice questions based on the following text. Follow these rules strictly:
+        """Create a clear, structured prompt for question generation"""
+        return f"""Generate exactly {num_questions} multiple choice questions based on this text. For each question:
+
+1. Create a clear, specific question focusing on key information
+2. Provide exactly 4 answer options
+3. Ensure one and only one option is correct
+4. Keep options concise (under 10 words each)
+5. Avoid subjective or ambiguous questions
+6. Make all options plausible but only one correct
 
-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:
+Return ONLY a JSON array in this exact format:
 [
     {{
-        "question": "Clear question text here?",
+        "question": "Question text here?",
         "options": [
-            "Brief option 1",
-            "Brief option 2",
-            "Brief option 3",
-            "Brief option 4"
+            "Option 1",
+            "Option 2",
+            "Option 3",
+            "Option 4"
         ],
         "correct_answer": 0
     }}
 ]
 
+The correct_answer should be the index (0-3) of the correct option.
+Return only the JSON array, no other text.
+
 Text to generate questions from:
-{text}
+{text.strip()}"""
 
-Important: Return only the JSON array, no other text or formatting."""
-    
     def _parse_response(self, response_text: str) -> List[Dict]:
-        """Parse response with improved error handling"""
+        """Parse API response with robust error handling"""
         try:
             # Clean up the response text
-            cleaned_text = response_text.strip()
-            cleaned_text = cleaned_text.replace('```json', '').replace('```', '').strip()
+            cleaned = response_text.strip()
+            # Remove any markdown code block markers
+            cleaned = cleaned.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")
+            start = cleaned.find('[')
+            end = cleaned.rfind(']') + 1
             
-            json_text = cleaned_text[start_idx:end_idx + 1]
+            if start == -1 or end == 0:
+                raise ValueError("No JSON array found in response")
+                
+            json_str = cleaned[start:end]
             
-            # Attempt to parse the JSON
+            # Parse JSON
             try:
-                return json.loads(json_text)
+                questions = json.loads(json_str)
             except json.JSONDecodeError as e:
                 print(f"JSON Parse Error: {str(e)}")
-                print(f"Attempted to parse: {json_text}")
+                print(f"Attempted to parse: {json_str}")
                 raise
                 
+            if not isinstance(questions, list):
+                raise ValueError("Response is not a list of questions")
+                
+            return questions
+            
         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)}")
+            raise ValueError(f"Failed to parse questions: {str(e)}")
     
     def _validate_questions(self, questions: List[Dict], num_questions: int) -> List[Question]:
-        """Validate questions with improved error checking"""
+        """Validate and convert questions to Question objects"""
         validated = []
         
-        for q in questions:
+        for q in questions[:num_questions]:
             try:
-                if not self._is_valid_question(q):
-                    print(f"Invalid question format: {q}")
+                # Validate question structure
+                if not isinstance(q, dict):
                     continue
                     
+                required_keys = {"question", "options", "correct_answer"}
+                if not all(key in q for key in required_keys):
+                    continue
+                    
+                if not isinstance(q["options"], list) or len(q["options"]) != 4:
+                    continue
+                    
+                # Convert correct_answer to int and validate
+                try:
+                    correct_idx = int(q["correct_answer"])
+                    if not 0 <= correct_idx < 4:
+                        continue
+                except (ValueError, TypeError):
+                    continue
+                
+                # Create Question object
                 validated.append(Question(
-                    question=q["question"].strip(),
-                    options=[str(opt).strip()[:100] for opt in q["options"]],
-                    correct_answer=int(q["correct_answer"]) % 4
+                    question=str(q["question"]).strip(),
+                    options=[str(opt).strip() for opt in q["options"]],
+                    correct_answer=correct_idx
                 ))
+                
             except Exception as e:
                 print(f"Error validating question: {str(e)}")
                 continue
         
-        if not validated:
-            raise ValueError("No valid questions after validation")
-        
-        return validated[:num_questions]
-    
-    def _is_valid_question(self, question: Dict) -> bool:
-        """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
+        return validated
 
 class FontManager:
     """Manages font installation and loading for the certificate generator"""