Update app.py

app.py

@@ -21,14 +21,11 @@ logger = logging.getLogger(__name__)
 
 @dataclass(frozen=True)
 class Question:
-    """Immutable question data structure with validation"""
     question: str
-    options: Tuple[str, ...]  # Using tuple for immutability
+    options: List[str]
     correct_answer: int
 
     def __post_init__(self):
-        if not isinstance(self.options, tuple):
-            object.__setattr__(self, 'options', tuple(self.options))
         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:
@@ -36,87 +33,57 @@ class Question:
 
 @dataclass(frozen=True)
 class QuizFeedback:
-    """Immutable feedback data structure"""
     is_correct: bool
     selected: Optional[str]
     correct_answer: str
 
-class CacheableQuizGenerator:
-    """Quiz generator with caching capabilities"""
+class QuizGenerator:
     def __init__(self, api_key: str):
         self.client = Groq(api_key=api_key)
-        self._cache = {}
+        self._question_cache = lru_cache(maxsize=100)(self._generate_questions_internal)
     
-    @lru_cache(maxsize=100)
-    def _generate_cached_questions(self, text_hash: str, num_questions: int) -> List[Question]:
-        """Cache questions based on content hash"""
-        text = self._cache.get(text_hash)
-        if not text:
-            raise KeyError("Text not found in cache")
-        return self._generate_questions_internal(text, num_questions)
-
     def generate_questions(self, text: str, num_questions: int) -> List[Question]:
-        """Generate questions with caching"""
-        text_hash = hash(text)
-        self._cache[text_hash] = text
         try:
-            return self._generate_cached_questions(text_hash, num_questions)
+            # Use text hash as cache key
+            text_hash = hash(text)
+            return self._question_cache(text_hash, num_questions)
         except Exception as e:
             logger.error(f"Error generating questions: {e}")
             raise QuizGenerationError(f"Failed to generate questions: {e}")
 
-    def _generate_questions_internal(self, text: str, num_questions: int) -> List[Question]:
-        """Internal question generation logic"""
-        try:
-            response = self._get_llm_response(text, num_questions)
-            questions = self._parse_response(response)
-            return self._validate_questions(questions, num_questions)
-        except Exception as e:
-            logger.error(f"Error in question generation: {e}")
-            raise
-
-    def _get_llm_response(self, text: str, num_questions: int) -> str:
-        """Get response from LLM with retry logic"""
+    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
+
         for attempt in range(max_retries):
             try:
                 response = self.client.chat.completions.create(
-                    messages=self._create_messages(text, num_questions),
+                    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
                 )
-                return response.choices[0].message.content
+                
+                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
-                logger.warning(f"Retry {attempt + 1}/{max_retries} after error: {e}")
+                    raise QuizGenerationError(f"Failed after {max_retries} attempts: {last_error}")
                 continue
-
-    @staticmethod
-    def _create_messages(text: str, num_questions: int) -> List[Dict[str, str]]:
-        """Create messages for LLM prompt"""
-        return [
-            {
-                "role": "system",
-                "content": "You are a quiz generator. Create clear questions with concise answer options."
-            },
-            {
-                "role": "user",
-                "content": f"""Generate exactly {num_questions} multiple choice questions based on this text:
-                
-                {text}
-                
-                Return only a JSON array with this format:
-                [
-                    {{
-                        "question": "Question text?",
-                        "options": ["Option 1", "Option 2", "Option 3", "Option 4"],
-                        "correct_answer": 0
-                    }}
-                ]"""
-            }
-        ]
     
     def _parse_response(self, response_text: str) -> List[Dict]:
         """Parse response with improved error handling"""
@@ -134,18 +101,20 @@ class CacheableQuizGenerator:
             
             json_text = cleaned_text[start_idx:end_idx + 1]
             
-            # Attempt to parse the JSON
             try:
-                return json.loads(json_text)
+                parsed = json.loads(json_text)
+                if not isinstance(parsed, list):
+                    raise ValueError("Response is not a JSON array")
+                return parsed
             except json.JSONDecodeError as e:
-                print(f"JSON Parse Error: {str(e)}")
-                print(f"Attempted to parse: {json_text}")
+                logger.error(f"JSON Parse Error: {e}")
+                logger.debug(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)}")
+            logger.error(f"Error parsing response: {e}")
+            logger.debug(f"Original response: {response_text}")
+            raise ValueError(f"Failed to parse response: {e}")
     
     def _validate_questions(self, questions: List[Dict], num_questions: int) -> List[Question]:
         """Validate questions with improved error checking"""
@@ -154,7 +123,7 @@ class CacheableQuizGenerator:
         for q in questions:
             try:
                 if not self._is_valid_question(q):
-                    print(f"Invalid question format: {q}")
+                    logger.warning(f"Invalid question format: {q}")
                     continue
                     
                 validated.append(Question(
@@ -163,7 +132,7 @@ class CacheableQuizGenerator:
                     correct_answer=int(q["correct_answer"]) % 4
                 ))
             except Exception as e:
-                print(f"Error validating question: {str(e)}")
+                logger.error(f"Error validating question: {e}")
                 continue
         
         if not validated:
@@ -455,61 +424,57 @@ class CertificateGenerator:
 
     
 class QuizApp:
-    """Enhanced quiz application with proper state management"""
     def __init__(self, api_key: str):
-        self.quiz_generator = CacheableQuizGenerator(api_key)
+        self.quiz_generator = QuizGenerator(api_key)
         self.certificate_generator = CertificateGenerator()
         self._current_questions: List[Question] = []
         self._user_answers: List[Optional[str]] = []
-    
-    @property
-    def current_questions(self) -> List[Question]:
-        """Get current questions with defensive copy"""
-        return self._current_questions.copy()
-    
-    def set_questions(self, questions: List[Question]) -> None:
-        """Set current questions with validation"""
-        if not all(isinstance(q, Question) for q in questions):
-            raise ValueError("All elements must be Question instances")
-        self._current_questions = questions.copy()
-        self._user_answers = [None] * len(questions)
 
-    def submit_answer(self, question_idx: int, answer: Optional[str]) -> None:
-        """Submit an answer with validation"""
-        if not 0 <= question_idx < len(self._current_questions):
-            raise ValueError(f"Invalid question index: {question_idx}")
-        self._user_answers[question_idx] = answer
-
-    def calculate_score(self) -> Tuple[float, bool, List[QuizFeedback]]:
-        """Calculate quiz score with proper validation"""
-        if not self._current_questions or not self._user_answers:
-            return 0.0, False, []
+    def generate_questions(self, text: str, num_questions: int) -> Tuple[bool, List[Question]]:
+        """Generate quiz questions with improved error handling"""
+        try:
+            questions = self.quiz_generator.generate_questions(text, num_questions)
+            self._current_questions = questions
+            self._user_answers = [None] * len(questions)
+            return True, questions
+        except Exception as e:
+            logger.error(f"Error generating questions: {e}")
+            return False, []
 
-        if len(self._current_questions) != len(self._user_answers):
-            raise ValueError("Questions and answers length mismatch")
+    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:
+            return 0, False, []
+        
+        if len(answers) != len(self._current_questions):
+            logger.warning("Answer count mismatch with questions")
+            return 0, False, []
 
         feedback = []
-        correct_count = 0
-
-        for question, answer in zip(self._current_questions, self._user_answers):
+        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_count += 1
+                        correct += 1
                 except ValueError:
-                    pass
-
+                    logger.warning(f"Invalid answer selected: {answer}")
+            
             feedback.append(QuizFeedback(
                 is_correct=is_correct,
                 selected=answer,
-                correct_answer=question.options[question.correct_answer]
+                correct_answer=correct_answer
             ))
-
-        score = (correct_count / 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]:
         """
@@ -562,6 +527,8 @@ 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]: