Update app.py

app.py

@@ -5,80 +5,118 @@ from PIL import Image, ImageDraw, ImageFont
 from datetime import datetime
 import json
 import tempfile
-from typing import List, Dict, Tuple, Optional
+from typing import List, Dict, Tuple, Optional, Any
 from dataclasses import dataclass
 import subprocess
+from pathlib import Path
+import logging
+from functools import lru_cache
 
-@dataclass
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+@dataclass(frozen=True)
 class Question:
+    """Immutable question data structure with validation"""
     question: str
-    options: List[str]
+    options: Tuple[str, ...]  # Using tuple for immutability
     correct_answer: int
 
-@dataclass
+    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:
+            raise ValueError(f"Must have exactly 4 options, got {len(self.options)}")
+
+@dataclass(frozen=True)
 class QuizFeedback:
+    """Immutable feedback data structure"""
     is_correct: bool
     selected: Optional[str]
     correct_answer: str
 
-class QuizGenerator:
+class CacheableQuizGenerator:
+    """Quiz generator with caching capabilities"""
     def __init__(self, api_key: str):
         self.client = Groq(api_key=api_key)
+        self._cache = {}
     
+    @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]:
-        prompt = self._create_prompt(text, num_questions)
-        
+        """Generate questions with caching"""
+        text_hash = hash(text)
+        self._cache[text_hash] = text
         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": prompt
-                    }
-                ],
-                model="llama-3.2-3b-preview",
-                temperature=0,
-                max_tokens=2048
-            )
-            
-            questions = self._parse_response(response.choices[0].message.content)
+            return self._generate_cached_questions(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:
-            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:
-
-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
-    }}
-]
-
-Text to generate questions from:
-{text}
-
-Important: Return only the JSON array, no other text or formatting."""
+            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"""
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                response = self.client.chat.completions.create(
+                    messages=self._create_messages(text, num_questions),
+                    model="llama-3.2-3b-preview",
+                    temperature=0,
+                    max_tokens=2048
+                )
+                return response.choices[0].message.content
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    raise
+                logger.warning(f"Retry {attempt + 1}/{max_retries} after error: {e}")
+                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"""
@@ -417,54 +455,60 @@ class CertificateGenerator:
 
     
 class QuizApp:
+    """Enhanced quiz application with proper state management"""
     def __init__(self, api_key: str):
-        self.quiz_generator = QuizGenerator(api_key)
+        self.quiz_generator = CacheableQuizGenerator(api_key)
         self.certificate_generator = CertificateGenerator()
-        self.current_questions: List[Question] = []
-
-    def generate_questions(self, text: str, num_questions: int) -> Tuple[bool, List[Question]]:
-        """
-        Generate quiz questions using the QuizGenerator
-        Returns (success, questions) tuple
-        """
-        try:
-            questions = self.quiz_generator.generate_questions(text, num_questions)
-            self.current_questions = questions
-            return True, questions
-        except Exception as e:
-            print(f"Error generating questions: {e}")
-            return False, []
+        self._current_questions: List[Question] = []
+        self._user_answers: List[Optional[str]] = []
     
-    def calculate_score(self, answers: List[Optional[str]]) -> Tuple[float, bool, List[QuizFeedback]]:
-        """
-        Calculate the quiz score and generate feedback
-        Returns (score, passed, feedback) tuple
-        """
-        if not answers or not self.current_questions:
-            return 0, False, []
-        
+    @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, []
+
+        if len(self._current_questions) != len(self._user_answers):
+            raise ValueError("Questions and answers length mismatch")
+
         feedback = []
-        correct = 0
-        
-        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
+        correct_count = 0
+
+        for question, answer in zip(self._current_questions, self._user_answers):
+            is_correct = False
+            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
+                except ValueError:
+                    pass
+
+            feedback.append(QuizFeedback(
+                is_correct=is_correct,
+                selected=answer,
+                correct_answer=question.options[question.correct_answer]
+            ))
+
+        score = (correct_count / 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]: