Update app.py

app.py

@@ -5,33 +5,17 @@ from PIL import Image, ImageDraw, ImageFont
 from datetime import datetime
 import json
 import tempfile
-from typing import List, Dict, Tuple, Optional, Any
+from typing import List, Dict, Tuple, Optional
 from dataclasses import dataclass
 import subprocess
-from pathlib import Path
-import logging
-from functools import lru_cache
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-@dataclass(frozen=True)
+@dataclass
 class Question:
     question: str
     options: List[str]
     correct_answer: int
 
-    def __post_init__(self):
-        if not (0 <= self.correct_answer < len(self.options)):
-            raise ValueError(f"Correct answer index {self.correct_answer} out of range")
-        if len(self.options) != 4:
-            raise ValueError(f"Must have exactly 4 options, got {len(self.options)}")
-
-@dataclass(frozen=True)
+@dataclass
 class QuizFeedback:
     is_correct: bool
     selected: Optional[str]
@@ -40,50 +24,61 @@ class QuizFeedback:
 class QuizGenerator:
     def __init__(self, api_key: str):
         self.client = Groq(api_key=api_key)
-        self._question_cache = lru_cache(maxsize=100)(self._generate_questions_internal)
     
     def generate_questions(self, text: str, num_questions: int) -> List[Question]:
+        prompt = self._create_prompt(text, num_questions)
+        
         try:
-            # Use text hash as cache key
-            text_hash = hash(text)
-            return self._question_cache(text_hash, num_questions)
+            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."""
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                model="llama-3.2-3b-preview",
+                temperature=0,
+                max_tokens=2048
+            )
+            
+            questions = self._parse_response(response.choices[0].message.content)
+            return self._validate_questions(questions, num_questions)
+            
         except Exception as e:
-            logger.error(f"Error generating questions: {e}")
-            raise QuizGenerationError(f"Failed to generate questions: {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"""Generate exactly {num_questions} multiple choice questions based on the following text. Follow these rules strictly:
 
-    def _generate_questions_internal(self, text_hash: str, num_questions: int) -> List[Question]:
-        """Internal question generation with retry logic"""
-        max_retries = 3
-        last_error = None
+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
+    }}
+]
 
-        for attempt in range(max_retries):
-            try:
-                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."""
-                        },
-                        {
-                            "role": "user",
-                            "content": self._create_prompt(text_hash, num_questions)
-                        }
-                    ],
-                    model="llama-3.2-3b-preview",
-                    temperature=0,
-                    max_tokens=2048
-                )
-                
-                questions = self._parse_response(response.choices[0].message.content)
-                return self._validate_questions(questions, num_questions)
-                
-            except Exception as e:
-                last_error = e
-                logger.warning(f"Attempt {attempt + 1}/{max_retries} failed: {e}")
-                if attempt == max_retries - 1:
-                    raise QuizGenerationError(f"Failed after {max_retries} attempts: {last_error}")
-                continue
+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]:
         """Parse response with improved error handling"""
@@ -101,20 +96,18 @@ class QuizGenerator:
             
             json_text = cleaned_text[start_idx:end_idx + 1]
             
+            # Attempt to parse the JSON
             try:
-                parsed = json.loads(json_text)
-                if not isinstance(parsed, list):
-                    raise ValueError("Response is not a JSON array")
-                return parsed
+                return json.loads(json_text)
             except json.JSONDecodeError as e:
-                logger.error(f"JSON Parse Error: {e}")
-                logger.debug(f"Attempted to parse: {json_text}")
+                print(f"JSON Parse Error: {str(e)}")
+                print(f"Attempted to parse: {json_text}")
                 raise
                 
         except Exception as e:
-            logger.error(f"Error parsing response: {e}")
-            logger.debug(f"Original response: {response_text}")
-            raise ValueError(f"Failed to parse response: {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"""
@@ -123,7 +116,7 @@ class QuizGenerator:
         for q in questions:
             try:
                 if not self._is_valid_question(q):
-                    logger.warning(f"Invalid question format: {q}")
+                    print(f"Invalid question format: {q}")
                     continue
                     
                 validated.append(Question(
@@ -132,7 +125,7 @@ class QuizGenerator:
                     correct_answer=int(q["correct_answer"]) % 4
                 ))
             except Exception as e:
-                logger.error(f"Error validating question: {e}")
+                print(f"Error validating question: {str(e)}")
                 continue
         
         if not validated:
@@ -427,54 +420,52 @@ class QuizApp:
     def __init__(self, api_key: str):
         self.quiz_generator = QuizGenerator(api_key)
         self.certificate_generator = CertificateGenerator()
-        self._current_questions: List[Question] = []
-        self._user_answers: List[Optional[str]] = []
+        self.current_questions: List[Question] = []
 
     def generate_questions(self, text: str, num_questions: int) -> Tuple[bool, List[Question]]:
-        """Generate quiz questions with improved error handling"""
+        """
+        Generate quiz questions using the QuizGenerator
+        Returns (success, questions) tuple
+        """
         try:
             questions = self.quiz_generator.generate_questions(text, num_questions)
-            self._current_questions = questions
-            self._user_answers = [None] * len(questions)
+            self.current_questions = questions
             return True, questions
         except Exception as e:
-            logger.error(f"Error generating questions: {e}")
+            print(f"Error generating questions: {e}")
             return False, []
-
+    
     def calculate_score(self, answers: List[Optional[str]]) -> Tuple[float, bool, List[QuizFeedback]]:
-        """Calculate quiz score with improved validation"""
-        if not answers or not self._current_questions:
+        """
+        Calculate the quiz score and generate feedback
+        Returns (score, passed, feedback) tuple
+        """
+        if not answers or not self.current_questions:
             return 0, False, []
         
-        if len(answers) != len(self._current_questions):
-            logger.warning("Answer count mismatch with questions")
-            return 0, False, []
-
         feedback = []
         correct = 0
         
-        for question, answer in zip(self._current_questions, answers):
-            is_correct = False
-            correct_answer = question.options[question.correct_answer]
-            
-            if answer is not None:
-                try:
-                    selected_index = question.options.index(answer)
-                    is_correct = selected_index == question.correct_answer
-                    if is_correct:
-                        correct += 1
-                except ValueError:
-                    logger.warning(f"Invalid answer selected: {answer}")
-            
-            feedback.append(QuizFeedback(
-                is_correct=is_correct,
-                selected=answer,
-                correct_answer=correct_answer
-            ))
+        for question, answer in zip(self.current_questions, answers):
+            if answer is None:
+                feedback.append(QuizFeedback(False, None, question.options[question.correct_answer]))
+                continue
+                
+            try:
+                selected_index = question.options.index(answer)
+                is_correct = selected_index == question.correct_answer
+                if is_correct:
+                    correct += 1
+                feedback.append(QuizFeedback(
+                    is_correct,
+                    answer,
+                    question.options[question.correct_answer]
+                ))
+            except ValueError:
+                feedback.append(QuizFeedback(False, answer, question.options[question.correct_answer]))
         
-        score = (correct / len(self._current_questions)) * 100
+        score = (correct / len(self.current_questions)) * 100
         return score, score >= 80, feedback
-
     
     def update_questions(self, text: str, num_questions: int) -> Tuple[gr.update, gr.update, List[gr.update], List[Question], gr.update]:
         """
@@ -527,8 +518,6 @@ class QuizApp:
             gr.update(selected=1)
         )
     
-    
-    
     def submit_quiz(self, q1: Optional[str], q2: Optional[str], q3: Optional[str], 
                    q4: Optional[str], q5: Optional[str], questions: List[Question]
     ) -> Tuple[gr.update, List[gr.update], float, str, gr.update]:
@@ -953,5 +942,4 @@ def create_quiz_interface():
 
 if __name__ == "__main__":
     demo = create_quiz_interface()
-    demo.launch() 
-            
+    demo.launch()