Update app.py

app.py

@@ -24,92 +24,85 @@ 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"""
+        """Generate quiz questions using llama-3.2-3b-preview model"""
         prompt = self._create_prompt(text, num_questions)
         
         try:
-            # Make API request with improved error handling
+            # API call with simplified parameters for llama-3.2-3b-preview
             response = self.client.chat.completions.create(
                 messages=[
                     {
                         "role": "system",
-                        "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."""
+                        "content": "You are a quiz generator. Generate multiple choice questions that are clear and focused."
                     },
                     {
                         "role": "user",
                         "content": prompt
                     }
                 ],
-                model="llama-3.2-3b-preview",  # 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
+                model="llama-3.2-3b-preview",
+                temperature=0.1,  # Very low temperature for consistent output
+                max_tokens=1024
             )
             
-            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)
+            # Extract content safely
+            if not response or not hasattr(response.choices[0], 'message'):
+                raise ValueError("Invalid API response structure")
+            
+            content = response.choices[0].message.content
+            if not content:
+                raise ValueError("Empty response content")
+            
+            # Parse and validate questions
+            questions = self._parse_response(content)
             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"Full error details: ", {
-                "error": str(e),
-                "response": getattr(response, 'choices', [{}])[0].get('message', {}).get('content', 'No content')
-                if 'response' in locals() else 'No response'
-            })
+            if 'response' in locals():
+                print("Response content:", getattr(response.choices[0], 'message', {}).content if hasattr(response, 'choices') else None)
             raise QuizGenerationError(f"Failed to generate questions: {str(e)}")
     
     def _create_prompt(self, text: str, num_questions: int) -> str:
-        """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
-
-Return ONLY a JSON array in this exact format:
+        """Create a simple, clear prompt optimized for llama-3.2-3b-preview"""
+        return f"""Create {num_questions} multiple choice questions about this text. Use this exact JSON format and nothing else:
 [
-    {{
-        "question": "Question text here?",
-        "options": [
-            "Option 1",
-            "Option 2",
-            "Option 3",
-            "Option 4"
-        ],
-        "correct_answer": 0
-    }}
+  {{
+    "question": "Write the question here?",
+    "options": [
+      "First option",
+      "Second option",
+      "Third option",
+      "Fourth option"
+    ],
+    "correct_answer": 0
+  }}
 ]
 
-The correct_answer should be the index (0-3) of the correct option.
-Return only the JSON array, no other text.
+Rules:
+1. Return only the JSON array
+2. Each question must have exactly 4 options
+3. correct_answer must be 0, 1, 2, or 3
+4. No explanations or additional text
+5. Keep options short and clear
 
-Text to generate questions from:
+Text to use:
 {text.strip()}"""
 
     def _parse_response(self, response_text: str) -> List[Dict]:
-        """Parse API response with robust error handling"""
+        """Parse response with improved error handling"""
         try:
             # Clean up the response text
             cleaned = response_text.strip()
-            # Remove any markdown code block markers
+            
+            # Remove any markdown or additional text
             cleaned = cleaned.replace('```json', '').replace('```', '').strip()
             
             # Find the JSON array
@@ -118,65 +111,71 @@ Text to generate questions from:
             
             if start == -1 or end == 0:
                 raise ValueError("No JSON array found in response")
-                
+            
             json_str = cleaned[start:end]
             
-            # Parse JSON
+            # Basic JSON structure validation before parsing
+            if not (json_str.startswith('[') and json_str.endswith(']')):
+                raise ValueError("Invalid JSON structure")
+            
             try:
                 questions = json.loads(json_str)
             except json.JSONDecodeError as e:
-                print(f"JSON Parse Error: {str(e)}")
-                print(f"Attempted to parse: {json_str}")
-                raise
-                
+                # Try to fix common JSON formatting issues
+                fixed_json = json_str.replace('}\n{', '},{')  # Fix line breaks between objects
+                fixed_json = fixed_json.replace(',]', ']')    # Fix trailing commas
+                questions = json.loads(fixed_json)
+            
             if not isinstance(questions, list):
-                raise ValueError("Response is not a list of questions")
-                
+                raise ValueError("Parsed JSON is not a list")
+            
             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 questions: {str(e)}")
+            print(f"Parse error details: {str(e)}")
+            print(f"Attempted to parse: {response_text}")
+            raise
     
     def _validate_questions(self, questions: List[Dict], num_questions: int) -> List[Question]:
-        """Validate and convert questions to Question objects"""
+        """Validate questions with strict checking"""
         validated = []
         
         for q in questions[:num_questions]:
             try:
-                # Validate question structure
+                # Skip invalid questions
                 if not isinstance(q, dict):
                     continue
-                    
-                required_keys = {"question", "options", "correct_answer"}
-                if not all(key in q for key in required_keys):
+                
+                # Check required fields
+                if not all(key in q for key in ['question', 'options', 'correct_answer']):
                     continue
-                    
-                if not isinstance(q["options"], list) or len(q["options"]) != 4:
+                
+                # Validate options
+                if not isinstance(q['options'], list) or len(q['options']) != 4:
                     continue
-                    
-                # Convert correct_answer to int and validate
+                
+                # Validate correct_answer
                 try:
-                    correct_idx = int(q["correct_answer"])
-                    if not 0 <= correct_idx < 4:
+                    correct_idx = int(q['correct_answer'])
+                    if not 0 <= correct_idx <= 3:
                         continue
                 except (ValueError, TypeError):
                     continue
                 
-                # Create Question object
+                # Create validated Question object
                 validated.append(Question(
-                    question=str(q["question"]).strip(),
-                    options=[str(opt).strip() for opt in q["options"]],
+                    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)}")
+                print(f"Validation error: {str(e)}")
                 continue
         
         return validated
 
+
 class FontManager:
     """Manages font installation and loading for the certificate generator"""