Update app.py

app.py

@@ -5,18 +5,53 @@ from PIL import Image, ImageDraw, ImageFont
 from datetime import datetime
 import json
 import tempfile
+from typing import List, Dict, Tuple, Optional
+from dataclasses import dataclass
 
-# Initialize Groq client
-client = Groq(
-    api_key=os.getenv("GROQ_API_KEY")
-)
+@dataclass
+class Question:
+    question: str
+    options: List[str]
+    correct_answer: int
 
-class QuizApp:
-    def __init__(self):
-        self.current_questions = []
+@dataclass
+class QuizFeedback:
+    is_correct: bool
+    selected: Optional[str]
+    correct_answer: str
+
+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]:
+        prompt = self._create_prompt(text, num_questions)
+        
+        try:
+            response = self.client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a quiz generator. Create clear questions with concise answer options."
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                model="llama-3.2-3b-preview",
+                temperature=0.3,
+                max_tokens=2048
+            )
+            
+            questions = self._parse_response(response.choices[0].message.content)
+            return self._validate_questions(questions, num_questions)
+            
+        except Exception as e:
+            raise QuizGenerationError(f"Failed to generate questions: {str(e)}")
     
-    def generate_questions(self, text, num_questions):
-        prompt = f"""Create exactly {num_questions} multiple choice questions based on this text:
+    def _create_prompt(self, text: str, num_questions: int) -> str:
+        return f"""Create exactly {num_questions} multiple choice questions based on this text:
         {text}
         
         For each question:
@@ -40,129 +75,231 @@ class QuizApp:
         ]
         Keep all options concise (10 words or less each).
         """
+    
+    def _parse_response(self, response_text: str) -> List[Dict]:
+        response_text = response_text.replace("```json", "").replace("```", "").strip()
+        start_idx = response_text.find("[")
+        end_idx = response_text.rfind("]")
         
-        try:
-            response = client.chat.completions.create(
-                messages=[
-                    {
-                        "role": "system",
-                        "content": "You are a quiz generator. Create clear questions with concise answer options."
-                    },
-                    {
-                        "role": "user",
-                        "content": prompt
-                    }
-                ],
-                model="llama-3.2-3b-preview",
-                temperature=0.3,
-                max_tokens=2048
-            )
-            
-            response_text = response.choices[0].message.content.strip()
-            response_text = response_text.replace("```json", "").replace("```", "").strip()
-            
-            start_idx = response_text.find("[")
-            end_idx = response_text.rfind("]")
+        if start_idx == -1 or end_idx == -1:
+            raise ValueError("No valid JSON array found in response")
             
-            if start_idx == -1 or end_idx == -1:
-                raise ValueError("No valid JSON array found in response")
-                
-            response_text = response_text[start_idx:end_idx + 1]
-            questions = json.loads(response_text)
-            
-            validated_questions = []
-            for q in questions:
-                if not all(key in q for key in ["question", "options", "correct_answer"]):
-                    continue
-                clean_options = [opt.strip()[:100] for opt in q["options"] if isinstance(opt, str)]
-                if len(clean_options) != 4:
-                    continue
-                clean_q = {
-                    "question": q["question"].strip(),
-                    "options": clean_options,
-                    "correct_answer": int(q["correct_answer"]) % 4
-                }
-                validated_questions.append(clean_q)
+        response_text = response_text[start_idx:end_idx + 1]
+        return json.loads(response_text)
+    
+    def _validate_questions(self, questions: List[Dict], num_questions: int) -> List[Question]:
+        validated = []
+        for q in questions:
+            if not self._is_valid_question(q):
+                continue
+            validated.append(Question(
+                question=q["question"].strip(),
+                options=[opt.strip()[:100] for opt in q["options"]],
+                correct_answer=int(q["correct_answer"]) % 4
+            ))
+        
+        if not validated:
+            raise ValueError("No valid questions after validation")
             
-            if not validated_questions:
-                raise ValueError("No valid questions after validation")
-                
-            self.current_questions = validated_questions[:num_questions]
+        return validated[:num_questions]
+    
+    def _is_valid_question(self, question: Dict) -> bool:
+        return (
+            all(key in question for key in ["question", "options", "correct_answer"]) and
+            isinstance(question["options"], list) and
+            len(question["options"]) == 4 and
+            all(isinstance(opt, str) for opt in question["options"])
+        )
+
+class CertificateGenerator:
+    def __init__(self):
+        self.certificate_size = (1200, 800)
+        self.border_color = '#4682B4'
+        self.background_color = '#F0F8FF'
+        
+    def generate(
+        self,
+        name: str,
+        score: float,
+        course_name: str,
+        company_logo: Optional[str] = None,
+        participant_photo: Optional[str] = None
+    ) -> str:
+        certificate = self._create_base_certificate()
+        draw = ImageDraw.Draw(certificate)
+        
+        fonts = self._load_fonts()
+        self._add_borders(draw)
+        self._add_content(draw, fonts, name, score, course_name)
+        self._add_images(certificate, company_logo, participant_photo)
+        
+        return self._save_certificate(certificate)
+    
+    def _create_base_certificate(self) -> Image.Image:
+        return Image.new('RGB', self.certificate_size, self.background_color)
+    
+    def _load_fonts(self) -> Dict[str, ImageFont.FreeTypeFont]:
+        try:
+            return {
+                'title': ImageFont.truetype("arial.ttf", 60),
+                'text': ImageFont.truetype("arial.ttf", 40),
+                'subtitle': ImageFont.truetype("arial.ttf", 30)
+            }
+        except Exception as e:
+            print(f"Font loading error: {e}. Using default font.")
+            default = ImageFont.load_default()
+            return {'title': default, 'text': default, 'subtitle': default}
+    
+    def _add_borders(self, draw: ImageDraw.Draw):
+        # Main borders
+        draw.rectangle([20, 20, 1180, 780], outline=self.border_color, width=3)
+        draw.rectangle([40, 40, 1160, 760], outline=self.border_color, width=1)
+        
+        # Decorative corners
+        self._add_decorative_corners(draw)
+    
+    def _add_decorative_corners(self, draw: ImageDraw.Draw):
+        corner_size = 20
+        corners = [
+            # Top-left
+            [(20, 40), (20 + corner_size, 40)],
+            [(40, 20), (40, 20 + corner_size)],
+            # Top-right
+            [(1180 - corner_size, 40), (1180, 40)],
+            [(1160, 20), (1160, 20 + corner_size)],
+            # Bottom-left
+            [(20, 760), (20 + corner_size, 760)],
+            [(40, 780 - corner_size), (40, 780)],
+            # Bottom-right
+            [(1180 - corner_size, 760), (1180, 760)],
+            [(1160, 780 - corner_size), (1160, 780)]
+        ]
+        
+        for corner in corners:
+            draw.line(corner, fill=self.border_color, width=2)
+    
+    def _add_content(
+        self,
+        draw: ImageDraw.Draw,
+        fonts: Dict[str, ImageFont.FreeTypeFont],
+        name: str,
+        score: float,
+        course_name: str
+    ):
+        # Title and headers
+        draw.text((600, 100), "CertifyMe AI", font=fonts['title'], fill=self.border_color, anchor="mm")
+        draw.text((600, 160), "Certificate of Achievement", font=fonts['subtitle'], fill=self.border_color, anchor="mm")
+        
+        # Main content
+        content = [
+            (300, "This is to certify that", 'black'),
+            (380, name.strip() or "Participant", self.border_color),
+            (460, "has successfully completed", 'black'),
+            (540, course_name.strip() or "Assessment", self.border_color),
+            (620, f"with a score of {score:.1f}%", 'black'),
+            (700, datetime.now().strftime("%B %d, %Y"), 'black')
+        ]
+        
+        for y, text, color in content:
+            draw.text((600, y), text, font=fonts['text'], fill=color, anchor="mm")
+    
+    def _add_images(
+        self,
+        certificate: Image.Image,
+        company_logo: Optional[str],
+        participant_photo: Optional[str]
+    ):
+        if company_logo:
+            self._add_image(certificate, company_logo, (50, 50))
+        if participant_photo:
+            self._add_image(certificate, participant_photo, (1000, 50))
+    
+    def _add_image(self, certificate: Image.Image, image_path: str, position: Tuple[int, int]):
+        try:
+            img = Image.open(image_path)
+            img.thumbnail((150, 150))
+            certificate.paste(img, position)
+        except Exception as e:
+            print(f"Error adding image: {e}")
+    
+    def _save_certificate(self, certificate: Image.Image) -> str:
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+        certificate.save(temp_file.name, 'PNG', quality=95)
+        return temp_file.name
+
+class QuizApp:
+    def __init__(self, api_key: str):
+        self.quiz_generator = QuizGenerator(api_key)
+        self.certificate_generator = CertificateGenerator()
+        self.current_questions: List[Question] = []
+    
+    def generate_questions(self, text: str, num_questions: int) -> Tuple[bool, List[Question]]:
+        try:
+            self.current_questions = self.quiz_generator.generate_questions(text, num_questions)
             return True, self.current_questions
-            
         except Exception as e:
-            print(f"Error in question generation: {str(e)}")
+            print(f"Error generating questions: {e}")
             return False, []
-
-    def calculate_score(self, answers):
+    
+    def calculate_score(self, answers: List[Optional[str]]) -> Tuple[float, bool, List[QuizFeedback]]:
         if not answers or not self.current_questions:
-            return 0, None, []
+            return 0, False, []
         
-        total = len(self.current_questions)
-        correct = 0
         feedback = []
+        correct = 0
         
-        for i, (q, a) in enumerate(zip(self.current_questions, answers)):
+        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:
-                if a is not None:
-                    selected_index = q["options"].index(a)
-                    is_correct = selected_index == q["correct_answer"]
-                    if is_correct:
-                        correct += 1
-                    feedback.append({
-                        "is_correct": is_correct,
-                        "selected": a,
-                        "correct_answer": q["options"][q["correct_answer"]]
-                    })
-                else:
-                    feedback.append({
-                        "is_correct": False,
-                        "selected": None,
-                        "correct_answer": q["options"][q["correct_answer"]]
-                    })
-            except (ValueError, TypeError) as e:
-                print(f"Error processing answer {i}: {e}")
-                feedback.append({
-                    "is_correct": False,
-                    "selected": None,
-                    "correct_answer": q["options"][q["correct_answer"]]
-                })
-        
-        score = (correct / total) * 100
-        passed = score >= 80
+                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]))
         
-        return score, passed, feedback
-            
+        score = (correct / len(self.current_questions)) * 100
+        return score, score >= 80, feedback
 
-# Update the interface functions
 def create_quiz_interface():
-    quiz_app = QuizApp()
+    if not os.getenv("GROQ_API_KEY"):
+        raise EnvironmentError("Please set your GROQ_API_KEY environment variable")
+        
+    quiz_app = QuizApp(os.getenv("GROQ_API_KEY"))
     
     with gr.Blocks(title="CertifyMe AI", theme=gr.themes.Soft()) as demo:
+        # State management
         current_questions = gr.State([])
         
-        # Header
+        # UI Components layout
         gr.Markdown("""
         # 🎓 CertifyMe AI
         ### Transform Your Knowledge into Recognized Achievements
         """)
         
-        # Tabs
         with gr.Tabs() as tabs:
-            # Step 1: Profile Setup
-            with gr.Tab("📋 Step 1: Profile Setup") as tab1:
+            # Profile Setup Tab
+            with gr.Tab("📋 Step 1: Profile Setup"):
                 with gr.Row():
                     name = gr.Textbox(label="Full Name", placeholder="Enter your full name")
                     email = gr.Textbox(label="Email", placeholder="Enter your email")
                 
                 text_input = gr.Textbox(
-                    label="Learning Content", 
+                    label="Learning Content",
                     placeholder="Enter the text content you want to be assessed on",
                     lines=10
                 )
                 
                 num_questions = gr.Slider(
-                    minimum=1, 
+                    minimum=1,
                     maximum=5,
                     value=3,
                     step=1,
@@ -175,25 +312,18 @@ def create_quiz_interface():
                 
                 generate_btn = gr.Button("Generate Assessment", variant="primary", size="lg")
             
-            # Step 2: Take Assessment
-            with gr.Tab("📝 Step 2: Take Assessment") as tab2:
+            # Assessment Tab
+            with gr.Tab("📝 Step 2: Take Assessment"):
                 feedback_box = gr.Markdown("")
                 question_box = gr.Markdown("")
-                answers = []
-                for i in range(5):
-                    with gr.Group():
-                        radio = gr.Radio(
-                            choices=[],
-                            label=f"Question {i+1}",
-                            visible=False,
-                            interactive=True
-                        )
-                        answers.append(radio)
-                
+                answers = [
+                    gr.Radio(choices=[], label=f"Question {i+1}", visible=False)
+                    for i in range(5)
+                ]
                 submit_btn = gr.Button("Submit Assessment", variant="primary", size="lg")
             
-            # Step 3: Get Certified
-            with gr.Tab("🎓 Step 3: Get Certified") as tab3:
+            # Certification Tab
+            with gr.Tab("🎓 Step 3: Get Certified"):
                 score_display = gr.Number(label="Your Score")
                 result_message = gr.Markdown("")
                 course_name = gr.Textbox(
@@ -201,115 +331,10 @@ def create_quiz_interface():
                     value="Professional Assessment Certification"
                 )
                 certificate_display = gr.Image(label="Your Certificate")
-
-        def update_questions(text, num_questions):
-            if not text.strip():
-                return (
-                    gr.update(value=""),
-                    gr.update(value="⚠️ Please enter some text content to generate questions."),
-                    *[gr.update(visible=False, choices=[]) for _ in range(5)],
-                    [],
-                    gr.update(selected=1)
-                )
-            
-            success, questions = quiz_app.generate_questions(text, num_questions)
-            
-            if not success or not questions:
-                return (
-                    gr.update(value=""),
-                    gr.update(value="❌ Failed to generate questions. Please try again."),
-                    *[gr.update(visible=False, choices=[]) for _ in range(5)],
-                    [],
-                    gr.update(selected=1)
-                )
-            
-            # Create question display
-            questions_html = "# 📝 Assessment Questions\n\n"
-            questions_html += "> Please select one answer for each question.\n\n"
-            
-            # Update radio buttons
-            updates = []
-            for i, q in enumerate(questions):
-                questions_html += f"### Question {i+1}\n{q['question']}\n\n"
-                updates.append(gr.update(
-                    visible=True,
-                    choices=q["options"],
-                    value=None,
-                    label=f"Select your answer:"
-                ))
-            
-            # Hide unused radio buttons
-            for i in range(len(questions), 5):
-                updates.append(gr.update(visible=False, choices=[]))
-            
-            return (
-                gr.update(value=questions_html),
-                gr.update(value=""),
-                *updates,
-                questions,
-                gr.update(selected=1)
-            )
-
-        def submit_quiz(q1, q2, q3, q4, q5, questions):
-            answers = [q1, q2, q3, q4, q5][:len(questions)]
-            
-            if not all(a is not None for a in answers):
-                return (
-                    gr.update(value="⚠️ Please answer all questions before submitting."),
-                    *[gr.update() for _ in range(5)],
-                    0,
-                    "",
-                    gr.update(selected=1)
-                )
-            
-            score, passed, feedback = quiz_app.calculate_score(answers)
-            
-            # Create feedback HTML
-            feedback_html = "# Assessment Results\n\n"
-            for i, (q, f) in enumerate(zip(quiz_app.current_questions, feedback)):
-                color = "green" if f["is_correct"] else "red"
-                symbol = "✅" if f["is_correct"] else "❌"
-                feedback_html += f"""
-                ### Question {i+1}
-                {q["question"]}
-                
-                <div style="color: {color}; padding: 10px; margin: 5px 0; border-left: 3px solid {color};">
-                    {symbol} Your answer: {f["selected"]}
-                    {'' if f["is_correct"] else f'<br>Correct answer: {f["correct_answer"]}'}
-                </div>
-                """
-            
-            # Add result message
-            if passed:
-                feedback_html += f"""
-                <div style="background-color: #e6ffe6; padding: 20px; margin-top: 20px; border-radius: 10px;">
-                    <h3 style="color: #008000;">🎉 Congratulations!</h3>
-                    <p>You passed the assessment with a score of {score:.1f}%</p>
-                    <p>Your certificate has been generated.</p>
-                </div>
-                """
-                result_msg = f"🎉 Congratulations! You passed with {score:.1f}%"
-            else:
-                feedback_html += f"""
-                <div style="background-color: #ffe6e6; padding: 20px; margin-top: 20px; border-radius: 10px;">
-                    <h3 style="color: #cc0000;">Please Try Again</h3>
-                    <p>Your score: {score:.1f}%</p>
-                    <p>You need 80% or higher to pass and receive a certificate.</p>
-                </div>
-                """
-                result_msg = f"Score: {score:.1f}%. You need 80% to pass."
-            
-            return (
-                gr.update(value=feedback_html),
-                *[gr.update(visible=False) for _ in range(5)],
-                score,
-                result_msg,
-                gr.update(selected=2)
-            )
         
         # Event handlers
         generate_btn.click(
-            fn=update_questions,
+            fn=quiz_app.update_questions,
             inputs=[text_input, num_questions],
             outputs=[
                 question_box,
@@ -321,7 +346,7 @@ def create_quiz_interface():
         )
         
         submit_btn.click(
-            fn=submit_quiz,
+            fn=quiz_app.submit_quiz,
             inputs=[*answers, current_questions],
             outputs=[
                 feedback_box,
@@ -332,188 +357,14 @@ def create_quiz_interface():
             ]
         )
         
-        
-        def generate_certificate(score, name, course_name, company_logo=None, participant_photo=None):
-            """
-            Generate a certificate with custom styling and optional logo/photo
-            
-            Args:
-                score (float): Assessment score (0-100)
-                name (str): Participant's name
-                course_name (str): Name of the course/assessment
-                company_logo (str, optional): Path to company logo image
-                participant_photo (str, optional): Path to participant's photo
-            
-            Returns:
-                str: Path to generated certificate image file
-            """
-            try:
-                # Create certificate with a light blue background
-                certificate = Image.new('RGB', (1200, 800), '#F0F8FF')
-                draw = ImageDraw.Draw(certificate)
-                
-                # Try to load fonts, fallback to default if necessary
-                try:
-                    title_font = ImageFont.truetype("arial.ttf", 60)
-                    text_font = ImageFont.truetype("arial.ttf", 40)
-                    subtitle_font = ImageFont.truetype("arial.ttf", 30)
-                except Exception as e:
-                    print(f"Font loading error: {e}. Using default font.")
-                    title_font = ImageFont.load_default()
-                    text_font = ImageFont.load_default()
-                    subtitle_font = ImageFont.load_default()
-                
-                # Add decorative border
-                border_color = '#4682B4'  # Steel blue
-                draw.rectangle([20, 20, 1180, 780], outline=border_color, width=3)
-                
-                # Add inner border
-                draw.rectangle([40, 40, 1160, 760], outline=border_color, width=1)
-                
-                # Add certificate content
-                # Title
-                draw.text(
-                    (600, 100),
-                    "CertifyMe AI",
-                    font=title_font,
-                    fill='#4682B4',
-                    anchor="mm"
-                )
-                
-                # Subtitle
-                draw.text(
-                    (600, 160),
-                    "Certificate of Achievement",
-                    font=subtitle_font,
-                    fill='#4682B4',
-                    anchor="mm"
-                )
-                
-                # Main content
-                draw.text(
-                    (600, 300),
-                    "This is to certify that",
-                    font=text_font,
-                    fill='black',
-                    anchor="mm"
-                )
-                
-                # Participant name
-                name = name.strip() if name else "Participant"
-                draw.text(
-                    (600, 380),
-                    name,
-                    font=text_font,
-                    fill='#4682B4',
-                    anchor="mm"
-                )
-                
-                # Completion text
-                draw.text(
-                    (600, 460),
-                    "has successfully completed",
-                    font=text_font,
-                    fill='black',
-                    anchor="mm"
-                )
-                
-                # Course name
-                course_name = course_name.strip() if course_name else "Assessment"
-                draw.text(
-                    (600, 540),
-                    course_name,
-                    font=text_font,
-                    fill='#4682B4',
-                    anchor="mm"
-                )
-                
-                # Score
-                draw.text(
-                    (600, 620),
-                    f"with a score of {score:.1f}%",
-                    font=text_font,
-                    fill='black',
-                    anchor="mm"
-                )
-                
-                # Date
-                current_date = datetime.now().strftime("%B %d, %Y")
-                draw.text(
-                    (600, 700),
-                    current_date,
-                    font=text_font,
-                    fill='black',
-                    anchor="mm"
-                )
-                
-                # Add logo if provided
-                if company_logo is not None:
-                    try:
-                        logo = Image.open(company_logo)
-                        # Maintain aspect ratio
-                        logo.thumbnail((150, 150))
-                        # Calculate position to place logo
-                        logo_x = 50
-                        logo_y = 50
-                        certificate.paste(logo, (logo_x, logo_y))
-                    except Exception as e:
-                        print(f"Error adding logo: {e}")
-                
-                # Add photo if provided
-                if participant_photo is not None:
-                    try:
-                        photo = Image.open(participant_photo)
-                        # Maintain aspect ratio
-                        photo.thumbnail((150, 150))
-                        # Calculate position to place photo
-                        photo_x = 1000
-                        photo_y = 50
-                        certificate.paste(photo, (photo_x, photo_y))
-                    except Exception as e:
-                        print(f"Error adding photo: {e}")
-                
-                # Add decorative corners
-                corner_size = 20
-                corner_color = '#4682B4'
-                
-                # Top-left corner
-                draw.line([(20, 40), (20 + corner_size, 40)], fill=corner_color, width=2)
-                draw.line([(40, 20), (40, 20 + corner_size)], fill=corner_color, width=2)
-                
-                # Top-right corner
-                draw.line([(1180 - corner_size, 40), (1180, 40)], fill=corner_color, width=2)
-                draw.line([(1160, 20), (1160, 20 + corner_size)], fill=corner_color, width=2)
-                
-                # Bottom-left corner
-                draw.line([(20, 760), (20 + corner_size, 760)], fill=corner_color, width=2)
-                draw.line([(40, 780 - corner_size), (40, 780)], fill=corner_color, width=2)
-                
-                # Bottom-right corner
-                draw.line([(1180 - corner_size, 760), (1180, 760)], fill=corner_color, width=2)
-                draw.line([(1160, 780 - corner_size), (1160, 780)], fill=corner_color, width=2)
-                
-                # Save certificate
-                temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-                certificate.save(temp_file.name, 'PNG', quality=95)
-                return temp_file.name
-                
-            except Exception as e:
-                print(f"Error generating certificate: {e}")
-                return None
-
-            # Certificate generation event handler
-
         score_display.change(
-            fn=generate_certificate,
+            fn=quiz_app.certificate_generator.generate,
             inputs=[score_display, name, course_name, company_logo, participant_photo],
             outputs=certificate_display
         )
+    
     return demo
 
 if __name__ == "__main__":
-    if not os.getenv("GROQ_API_KEY"):
-        print("Please set your GROQ_API_KEY environment variable")
-        exit(1)
-    
     demo = create_quiz_interface()
     demo.launch()