Update app.py

app.py

@@ -8,6 +8,7 @@ import tempfile
 from typing import List, Dict, Tuple, Optional
 from dataclasses import dataclass
 import subprocess
+import re
 
 @dataclass
 class Question:
@@ -26,15 +27,16 @@ class QuizGenerator:
         self.client = Groq(api_key=api_key)
     
     def generate_questions(self, text: str, num_questions: int) -> List[Question]:
+        """Generate quiz questions using llama-3.2-3b-preview model"""
         prompt = self._create_prompt(text, num_questions)
         
         try:
+            # API call with simplified parameters
             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 that are clear and focused."
                     },
                     {
                         "role": "user",
@@ -42,112 +44,148 @@ class QuizGenerator:
                     }
                 ],
                 model="llama-3.2-3b-preview",
-                temperature=0,
-                max_tokens=2048
+                temperature=0.1,
+                max_tokens=1024
             )
             
-            questions = self._parse_response(response.choices[0].message.content)
-            return self._validate_questions(questions, num_questions)
+            # Extract content safely
+            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"Response content: {response.choices[0].message.content if response else 'No response'}")
+            if 'response' in locals():
+                print("Response content:", content if 'content' in locals() else None)
             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:
-
-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:
+        """Create a simple, clear prompt optimized for llama-3.2-3b-preview"""
+        return f"""Create {num_questions} multiple choice questions about this text. Return only the JSON array in this exact format:
 [
-    {{
-        "question": "Clear question text here?",
-        "options": [
-            "Brief option 1",
-            "Brief option 2",
-            "Brief option 3",
-            "Brief option 4"
-        ],
-        "correct_answer": 0
-    }}
+  {{
+    "question": "Write the question here?",
+    "options": [
+      "First option",
+      "Second option",
+      "Third option",
+      "Fourth option"
+    ],
+    "correct_answer": 0
+  }}
 ]
 
-Text to generate questions from:
-{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
+
+Text to use:
+{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"""
         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 formatting
+            cleaned = cleaned.replace('```json', '').replace('```', '').strip()
             
             # Find the JSON array
-            start_idx = cleaned_text.find('[')
-            end_idx = cleaned_text.rfind(']')
+            start = cleaned.find('[')
+            end = cleaned.rfind(']') + 1
+            
+            if start == -1 or end == 0:
+                raise ValueError("No JSON array found in response")
             
-            if start_idx == -1 or end_idx == -1:
-                raise ValueError("No valid JSON array found in response")
+            json_str = cleaned[start:end]
             
-            json_text = cleaned_text[start_idx:end_idx + 1]
+            # Remove any trailing commas before closing brackets
+            json_str = re.sub(r',(\s*})', r'\1', json_str)
+            json_str = re.sub(r',(\s*])', r'\1', json_str)
             
-            # Attempt to parse the JSON
+            # Try to parse the cleaned 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
+                return json.loads(json_str)
+            except json.JSONDecodeError:
+                # If that fails, try using ast.literal_eval as a fallback
+                import ast
+                return ast.literal_eval(json_str)
                 
         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)}")
+            print(f"Parse error details: {str(e)}")
+            print(f"Attempted to parse: {response_text}")
+            
+            # Last resort: try to fix the JSON manually
+            try:
+                # Remove any trailing commas and fix newlines
+                fixed = re.sub(r',(\s*[}\]])', r'\1', response_text)
+                fixed = fixed.replace('}\n{', '},{')
+                fixed = fixed.strip()
+                if not fixed.startswith('['):
+                    fixed = '[' + fixed
+                if not fixed.endswith(']'):
+                    fixed = fixed + ']'
+                return json.loads(fixed)
+            except:
+                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"""
+        """Validate questions with strict checking"""
         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}")
+                # Skip invalid questions
+                if not isinstance(q, dict):
+                    continue
+                
+                # Check required fields
+                if not all(key in q for key in ['question', 'options', 'correct_answer']):
                     continue
-                    
+                
+                # Validate options
+                if not isinstance(q['options'], list) or len(q['options']) != 4:
+                    continue
+                
+                # Validate correct_answer
+                try:
+                    correct_idx = int(q['correct_answer'])
+                    if not 0 <= correct_idx <= 3:
+                        continue
+                except (ValueError, TypeError):
+                    continue
+                
+                # Create validated 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)}")
+                print(f"Validation error: {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"""
+        return validated
+
+    def _is_valid_json(self, json_str: str) -> bool:
+        """Check if a string is valid JSON"""
         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)}")
+            json.loads(json_str)
+            return True
+        except:
             return False
 
 class FontManager: